{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.\n",
    "\n",
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run the following from the cs231n directory and try again:\n",
      "python setup.py build_ext --inplace\n",
      "You may also need to restart your iPython kernel\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)    # 乘积是w的D维度\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)   #所有维度相乘\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "sigmoid和tanh激活函数都有饱和问题，当数值太小或太大都会出现饱和现象，此时梯度就接近0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 3675) loss: 2.575159\n",
      "(Epoch 0 / 15) train acc: 0.166000; val_acc: 0.157000\n",
      "(Iteration 101 / 3675) loss: 1.946682\n",
      "(Iteration 201 / 3675) loss: 1.892399\n",
      "(Epoch 1 / 15) train acc: 0.454000; val_acc: 0.438000\n",
      "(Iteration 301 / 3675) loss: 1.817472\n",
      "(Iteration 401 / 3675) loss: 1.786500\n",
      "(Epoch 2 / 15) train acc: 0.481000; val_acc: 0.462000\n",
      "(Iteration 501 / 3675) loss: 1.595342\n",
      "(Iteration 601 / 3675) loss: 1.715361\n",
      "(Iteration 701 / 3675) loss: 1.707189\n",
      "(Epoch 3 / 15) train acc: 0.516000; val_acc: 0.459000\n",
      "(Iteration 801 / 3675) loss: 1.640745\n",
      "(Iteration 901 / 3675) loss: 1.571867\n",
      "(Epoch 4 / 15) train acc: 0.519000; val_acc: 0.501000\n",
      "(Iteration 1001 / 3675) loss: 1.518168\n",
      "(Iteration 1101 / 3675) loss: 1.588188\n",
      "(Iteration 1201 / 3675) loss: 1.553383\n",
      "(Epoch 5 / 15) train acc: 0.556000; val_acc: 0.513000\n",
      "(Iteration 1301 / 3675) loss: 1.495996\n",
      "(Iteration 1401 / 3675) loss: 1.442664\n",
      "(Epoch 6 / 15) train acc: 0.532000; val_acc: 0.484000\n",
      "(Iteration 1501 / 3675) loss: 1.514720\n",
      "(Iteration 1601 / 3675) loss: 1.445161\n",
      "(Iteration 1701 / 3675) loss: 1.377631\n",
      "(Epoch 7 / 15) train acc: 0.547000; val_acc: 0.506000\n",
      "(Iteration 1801 / 3675) loss: 1.466041\n",
      "(Iteration 1901 / 3675) loss: 1.543482\n",
      "(Epoch 8 / 15) train acc: 0.560000; val_acc: 0.512000\n",
      "(Iteration 2001 / 3675) loss: 1.329711\n",
      "(Iteration 2101 / 3675) loss: 1.402538\n",
      "(Iteration 2201 / 3675) loss: 1.473916\n",
      "(Epoch 9 / 15) train acc: 0.540000; val_acc: 0.510000\n",
      "(Iteration 2301 / 3675) loss: 1.441364\n",
      "(Iteration 2401 / 3675) loss: 1.347390\n",
      "(Epoch 10 / 15) train acc: 0.602000; val_acc: 0.523000\n",
      "(Iteration 2501 / 3675) loss: 1.246204\n",
      "(Iteration 2601 / 3675) loss: 1.391396\n",
      "(Epoch 11 / 15) train acc: 0.575000; val_acc: 0.521000\n",
      "(Iteration 2701 / 3675) loss: 1.524222\n",
      "(Iteration 2801 / 3675) loss: 1.498333\n",
      "(Iteration 2901 / 3675) loss: 1.306289\n",
      "(Epoch 12 / 15) train acc: 0.596000; val_acc: 0.530000\n",
      "(Iteration 3001 / 3675) loss: 1.144800\n",
      "(Iteration 3101 / 3675) loss: 1.541146\n",
      "(Epoch 13 / 15) train acc: 0.593000; val_acc: 0.531000\n",
      "(Iteration 3201 / 3675) loss: 1.277404\n",
      "(Iteration 3301 / 3675) loss: 1.359444\n",
      "(Iteration 3401 / 3675) loss: 1.334829\n",
      "(Epoch 14 / 15) train acc: 0.604000; val_acc: 0.534000\n",
      "(Iteration 3501 / 3675) loss: 1.392748\n",
      "(Iteration 3601 / 3675) loss: 1.243115\n",
      "(Epoch 15 / 15) train acc: 0.591000; val_acc: 0.536000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet(hidden_dim=256, reg=0.7)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "solver = Solver(model, data, \n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                     'learning_rate':1e-3\n",
    "                 },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=15, batch_size=200,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x203ab8bf080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "# # plt.rcParams['figure.figsize'] = (0.5, 0.5)   # set default size of plots\n",
    "# plt.subplots_adjust(wspace =0, hspace =0.2)  #调整子图间距\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 1.04e-08\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 1.32e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### w3一开始无法得到满意效果是由于在损失函数中没有加W3部分的正则化损失"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the learning rate and initialization scale to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 357422.248338\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.114000\n",
      "(Epoch 1 / 20) train acc: 0.360000; val_acc: 0.141000\n",
      "(Epoch 2 / 20) train acc: 0.540000; val_acc: 0.142000\n",
      "(Epoch 3 / 20) train acc: 0.680000; val_acc: 0.156000\n",
      "(Epoch 4 / 20) train acc: 0.840000; val_acc: 0.170000\n",
      "(Epoch 5 / 20) train acc: 0.880000; val_acc: 0.154000\n",
      "(Iteration 11 / 40) loss: 2990.880358\n",
      "(Epoch 6 / 20) train acc: 0.940000; val_acc: 0.152000\n",
      "(Epoch 7 / 20) train acc: 0.920000; val_acc: 0.146000\n",
      "(Epoch 8 / 20) train acc: 0.960000; val_acc: 0.150000\n",
      "(Epoch 9 / 20) train acc: 0.940000; val_acc: 0.142000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.142000\n",
      "(Iteration 21 / 40) loss: 1934.093573\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Iteration 31 / 40) loss: 0.000000\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.144000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.144000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x203ab8a9c50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e0\n",
    "learning_rate = 1e-4\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 166.501707\n",
      "(Epoch 0 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.101000\n",
      "(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.122000\n",
      "(Epoch 3 / 20) train acc: 0.380000; val_acc: 0.106000\n",
      "(Epoch 4 / 20) train acc: 0.520000; val_acc: 0.111000\n",
      "(Epoch 5 / 20) train acc: 0.760000; val_acc: 0.113000\n",
      "(Iteration 11 / 40) loss: 3.343141\n",
      "(Epoch 6 / 20) train acc: 0.840000; val_acc: 0.122000\n",
      "(Epoch 7 / 20) train acc: 0.920000; val_acc: 0.113000\n",
      "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.125000\n",
      "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.125000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.121000\n",
      "(Iteration 21 / 40) loss: 0.039138\n",
      "(Epoch 11 / 20) train acc: 0.980000; val_acc: 0.123000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Iteration 31 / 40) loss: 0.000644\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.121000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x203ad60e860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-3\n",
    "weight_scale = 1e-1\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "初始化会影响每层网络激活数据的分布，在使用tanh带有饱和的激活函数时，如果初始化过大，会导致各层进入饱和，网络各层的输出限制到1或-1，如果初始化太小，网络的输出的方差也很小最后趋于0，导致数据信息丢失严重，层数越多，这种现象越严重\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.571494\n",
      "(Epoch 0 / 5) train acc: 0.130000; val_acc: 0.117000\n",
      "(Iteration 11 / 200) loss: 2.284760\n",
      "(Iteration 21 / 200) loss: 2.031593\n",
      "(Iteration 31 / 200) loss: 2.036640\n",
      "(Epoch 1 / 5) train acc: 0.255000; val_acc: 0.254000\n",
      "(Iteration 41 / 200) loss: 1.891729\n",
      "(Iteration 51 / 200) loss: 1.913542\n",
      "(Iteration 61 / 200) loss: 1.918622\n",
      "(Iteration 71 / 200) loss: 1.895959\n",
      "(Epoch 2 / 5) train acc: 0.320000; val_acc: 0.286000\n",
      "(Iteration 81 / 200) loss: 1.923559\n",
      "(Iteration 91 / 200) loss: 1.895201\n",
      "(Iteration 101 / 200) loss: 1.886073\n",
      "(Iteration 111 / 200) loss: 1.734942\n",
      "(Epoch 3 / 5) train acc: 0.381000; val_acc: 0.318000\n",
      "(Iteration 121 / 200) loss: 1.654649\n",
      "(Iteration 131 / 200) loss: 2.003036\n",
      "(Iteration 141 / 200) loss: 1.715678\n",
      "(Iteration 151 / 200) loss: 1.735957\n",
      "(Epoch 4 / 5) train acc: 0.378000; val_acc: 0.335000\n",
      "(Iteration 161 / 200) loss: 1.709778\n",
      "(Iteration 171 / 200) loss: 1.656011\n",
      "(Iteration 181 / 200) loss: 1.649582\n",
      "(Iteration 191 / 200) loss: 1.699827\n",
      "(Epoch 5 / 5) train acc: 0.417000; val_acc: 0.321000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.695519\n",
      "(Epoch 0 / 5) train acc: 0.125000; val_acc: 0.127000\n",
      "(Iteration 11 / 200) loss: 2.248414\n",
      "(Iteration 21 / 200) loss: 2.019741\n",
      "(Iteration 31 / 200) loss: 1.872684\n",
      "(Epoch 1 / 5) train acc: 0.350000; val_acc: 0.319000\n",
      "(Iteration 41 / 200) loss: 1.802261\n",
      "(Iteration 51 / 200) loss: 1.855647\n",
      "(Iteration 61 / 200) loss: 1.787771\n",
      "(Iteration 71 / 200) loss: 1.912212\n",
      "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.327000\n",
      "(Iteration 81 / 200) loss: 1.795945\n",
      "(Iteration 91 / 200) loss: 1.621639\n",
      "(Iteration 101 / 200) loss: 1.569031\n",
      "(Iteration 111 / 200) loss: 1.498733\n",
      "(Epoch 3 / 5) train acc: 0.411000; val_acc: 0.332000\n",
      "(Iteration 121 / 200) loss: 1.758775\n",
      "(Iteration 131 / 200) loss: 1.639975\n",
      "(Iteration 141 / 200) loss: 1.360772\n",
      "(Iteration 151 / 200) loss: 1.388884\n",
      "(Epoch 4 / 5) train acc: 0.498000; val_acc: 0.341000\n",
      "(Iteration 161 / 200) loss: 1.413532\n",
      "(Iteration 171 / 200) loss: 1.528864\n",
      "(Iteration 181 / 200) loss: 1.607784\n",
      "(Iteration 191 / 200) loss: 1.354477\n",
      "(Epoch 5 / 5) train acc: 0.563000; val_acc: 0.365000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-2,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\lib\\site-packages\\matplotlib\\cbook\\deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3QAAANsCAYAAAATFepNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3X+cXHV5N/zPtZvZZCKYRTY0ZpM0eShibQxGNmifpJXCDQGRmKIGS7W2d2nw1oLweEcCD3dIU28JpBrF57GYRh/qS1EWCSGYtpGCP5ooSgJhww8jasRkA5IgCcIu7q/r+ePM7J45c3595/ye+bxfr7ySnT0zc+bMmcn3Otf3e12iqiAiIiIiIqLiact6B4iIiIiIiKgxDOiIiIiIiIgKigEdERERERFRQTGgIyIiIiIiKigGdERERERERAXFgI6IiIiIiKigGNAREVHTEJF2EXlZRObEuW0D+/FJEbk97sclIiJympT1DhARUesSkZdtP04F8DsAo5Wfr1DVr5k8nqqOAjgh7m2JiIjyigEdERFlRlXHAyoR+SWAy1X1P722F5FJqjqSxr4REREVAadcEhFRblWmLt4pIl8Xkd8C+ICI/LGIPCQix0TkWRG5VURKle0niYiKyNzKz1+t/P7fReS3IvJDEZlnum3l9xeKyE9F5LiIfF5EdonIX4d8HctF5InKPj8oIqfbfne9iBwWkZdE5Ccicnbl9reLyCOV238tIhtiOKRERNRkGNAREVHe/TmAOwBMA3AngBEAHwPQBWAxgAsAXOFz/8sA/C8ArwPwKwD/aLqtiJwCoBfAqsrzHgBwVpidF5E/BPBVAFcCmA7gPwHcJyIlEfmjyr6/VVVfC+DCyvMCwOcBbKjc/gcAvhnm+YiIqLUwoCMiorzbqar3qeqYqg6q6sOq+iNVHVHVXwDYBOAdPvf/pqruVtVhAF8D8JYGtn0XgL2qem/ldxsBHA25/+8HsE1VH6zcdz2A1wJ4G6zgdAqAP6pMJz1QeU0AMAzgNBE5WVV/q6o/Cvl8RETUQhjQERFR3h20/yAibxSR7SLynIi8BGAdrKyZl+ds/x6AfyEUr21n2vdDVRXAoRD7Xr3vM7b7jlXu262q+wF8HNZreL4ytXRGZdO/AfAmAPtF5Mci8s6Qz0dERC2EAR0REeWdOn7+IoDHAfxBZTriGgCS8D48C2BW9QcREQDdIe97GMDv2+7bVnmsfgBQ1a+q6mIA8wC0A7ipcvt+VX0/gFMAfBrA3SIyJfpLISKiZsKAjoiIiuZEAMcBvFJZn+a3fi4u3wLwVhG5WEQmwVrDNz3kfXsBLBORsyvFW1YB+C2AH4nIH4rIn4nIZACDlT+jACAiHxSRrkpG7ziswHYs3pdFRERFx4COiIiK5uMAPgQrKPoirEIpiVLVXwO4FMBnALwA4FQAj8Lqmxd03ydg7e8/AzgCq4jLssp6uskAboG1Hu85ACcBuKFy13cCeKpS3fOfAFyqqkMxviwiImoCYi0DICIiorBEpB3WVMr3qup/Zb0/RETUupihIyIiCkFELhCRaZXpkf8LVoXKH2e8W0RE1OIY0BEREYWzBMAvYE2PvADAclUNnHJJRESUJE65JCIiIiIiKihm6IiIiIiIiApqUtY74NTV1aVz587NejeIiIiIiIgysWfPnqOqGqo9Tu4Curlz52L37t1Z7wYREREREVEmROSZsNtyyiUREREREVFBMaAjIiIiIiIqKAZ0REREREREBcWAjoiIiIiIqKAY0BERERERERUUAzoiIiIiIqKCYkAXpK8X2DgfWNtp/d3Xm/UeERERERERAchhH7pc6esF7rsKGB60fj5+0PoZABasyG6/iIiIiIiIwAydvwfWTQRzVcOD1u1EREREREQZY0Dn5/ghs9uJiIiIiIhSxIDOz7RZZrcTERERERGliAGdn3PXAKVy7W2lsnU7ERERERFRxhjQ+VmwArj4VmDabABi/X3xrSyIQkREREREucAql0EWrGAAR0REREREucQMHRERERERUUExoCMiIiIiIiooBnREREREREQFxYCOiIiIiIiooBjQERERERERFRQDOiIiIiIiooJqOKATkdki8h0ReUpEnhCRj3lsd7aI7K1s873Gd5WIiIiIiIjsovShGwHwcVV9REROBLBHRO5X1SerG4hIJ4AvALhAVX8lIqdE3F8iIiIiIiKqaDhDp6rPquojlX//FsBTALodm10GYIuq/qqy3fONPh8RERERERHVimUNnYjMBbAQwI8cv3oDgJNE5LsiskdE/srj/itFZLeI7D5y5Egcu0RERERERNT0oky5BACIyAkA7gZwtaq+5PL4ZwI4F0AZwA9F5CFV/al9I1XdBGATAPT09GjUfYrT1kf7sWHHfhw+NoiZnWWsWno6li90JiKJiIiIiIjSFymgE5ESrGDua6q6xWWTQwCOquorAF4Rke8DOAPAT122zZ2tj/bjui37MDg8CgDoPzaI67bsAwAGdURERERElLkoVS4FwJcAPKWqn/HY7F4AfyIik0RkKoC3wVprVwgbduwfD+aqBodHsWHH/oz2iIiIiIiIaEKUDN1iAB8EsE9E9lZuux7AHABQ1dtU9SkR+Q8AfQDGAGxW1cej7HCaDh8bNLqdiIiIiIgoTQ0HdKq6E4CE2G4DgA2NPk+WZnaW0e8SvM3sLGewN0RERERERLViqXLZrFYtPR3lUnvNbaU2wcDQCOat3o7F6x/E1kf7M9o7IiIiIiJqdZGrXDazauGTapXLaeUSXhkawYsDwwBYJIWIiIiIiLLFDF2A5Qu7sWv1OTiw/iK8ZvIkDI/WdlWoK5LS1wtsnA+s7bT+7utNeY+JiIiIiKhVMENnILBISl8vcN9VwHDl5+MHrZ8BYMGKFPaQiIiIiIhaCTN0BryKoYzf/sC6iWCuanjQup2IiIiIiChmDOgMuBVJKZfasWrp6dYPxw+539HrdiIiIiIiogg45dKAs0jKzM4yVi09faIgyrRZ1jRLp2mzUtxLIiIiIiJqFQzoDC1f2O1d0fLcNbVr6ACgVLZuJyIiIiIiihmnXMZpwQrg4luBabMBiPX3xbeyIAoRERERESWCGbq4LVjBAI6IiIiIiFLBDB0REREREVFBMaAjIiIiIiIqKAZ0REREREREBcWAjoiIiIiIqKAY0BERERERERUUq1xGtPXRfu9G40RERERERAliQBfB1kf7cd2WfRgcHgUA9B8bxHVb9gGAZ1DHAJCIiIiIiOLCKZcRbNixfzyYqxocHsWGHftdt68GgP3HBqGYCAC3Ptqfwt4SEREREVGzYUAXweFjg0a3mwaAREREREREfhoO6ERktoh8R0SeEpEnRORjPtsuEpFREXlvo8+XRzM7y0a3mwaAREREREREfqJk6EYAfFxV/xDA2wF8VETe5NxIRNoB3AxgR4TnyqVVS09HudRec1u51I5VS0933d40ACQiIiIiIvLTcECnqs+q6iOVf/8WwFMA3Kp7XAngbgDPN/pcebV8YTduuuTN6O4sQwB0d5Zx0yVv9ixyEhgA9vUCG+cDazutv/t6E34FRERERERUZLFUuRSRuQAWAviR4/ZuAH8O4BwAi3zuvxLASgCYM2dOHLuUmuULu0NXqaxu51rlsq8XuO8qYLgy/fL4QetnAFiwIoldJyIiIiKighNVjfYAIicA+B6A/62qWxy/uwvAp1X1IRG5HcC3VPWbfo/X09Oju3fvjrRPierrBR5YBxw/BEybBZy7Jp6Aa+N8K4hzmjYbuObx6I9PRERERESFICJ7VLUnzLaRMnQiUoI1nfJrzmCuogfAN0QEALoAvFNERlR1a5TnzUySWbTjh8xuJyIiIiKilhelyqUA+BKAp1T1M27bqOo8VZ2rqnMBfBPARwobzAFWZm7YUZFyeNC6Papps8xuJyIiIiKilhelyuViAB8EcI6I7K38eaeIfFhEPhzT/uVLklm0c9cAJUe1y1LZup2IiIiIiMhFw1MuVXUnADHY/q8bfa7cmDbLfZ2btFmVKaOsqaveJ4n1eURERERE1JRiqXLZMs5dU7uGrkpHrb+jrqlbsIIBHBERERERhRZlymXrWbACuPhWq/IkBJD2+m3iWlNHREREREQUgBk6U/Ys2tpO921YmZKIiIiIiFLADF0UrExJREREREQZYkAXBStTEhERERFRhjjlMoowlSn7ej1/v/XRfmzYsR+Hjw1iZmcZq5aejuULuz2fznR7IiIiIiJqbgzoovKrTNnXW1sV01YFc+voYly3ZR8Gh60Kmf3HBnHdln0A4BqkbX2032h7IiIiIiJqfqKqWe9DjZ6eHt29e3fWu9Ewexbth1M+hhk4Ur/RtNlY/Ltb0X9ssO5X3Z1l7Fp9Tt3ti9c/6Lp9uwjGVFPN2DFTSERERESUHBHZo6o9YbZlhi5GzizaKXrEvfX68UM4/Gp9cAYAh12CNr/bRysBeVoZO2YKiYiIiIjyg0VRYrRhx/7xQAcADmuX+4bTZmFmZ9n1V6a32w0Oj2LDjv3BOxqB8zWm9bxERERERFSPAV2MnFm0W0ZWYEA7ajeqVMFctfR0lEu1jcnLpXasWnr6xA19vcDG+cDaTtwvH8F7O35gvA9xM80gEhERERFRcjjlMkYzO8s169y2jS0BhoHrO+7CDBytqXK5vLKN51o0R0GVqYPPYn1pM07omIR/ffkstImMT7d07kOarzGt5yUiIiIionosihIj5/oywMq63XTJm83Xl22cb1XFdJo2G7jm8Xify0Dcz8sCK0REREREtVgUJSPVQMQ3QLH3pSufZN02+GJ9D7vjh9yfpHL78oXd6D74Lcx+ZANO0SN4Xqbj4FtXYdHCC5J6eePPCwS8xpBYYIWIiIiIKBpm6NLk7EvnVCoDF99qBXUBGTrXx7LfvwC8WjF4tW4gIiIiImoFJhk6FkVJ0wPrvIM5wPrdA+usf5+7xgrQ7CoFVTwfa3gQz225HvNWb8fi9Q9i66P98e17AlhghYiIiIgoGgZ0afKaRum2zYIVVrZt2mwAYv1tz755PNYpehQKa/riNXfuxdwcB3dRWjQQERERERHX0KVr2iz3aZTObaoWrPCePunxWIf15PF/VyfT9h8bxKq7HsM/3PcEjg0MY2ZnGZ9909NY9PPPW4Ghc/1eSlYtPd21wEpN6wYiIiIiIvLEDF2a3KZR2tmnVDbwWAPagVtG3IOy4THFiwPDUABnvnQ/5u+5oRIQqvX3fVdZ6/JStHxhN2665M3o7ixDYK2dS7pKJxERERFRM2m4KIqIzAbwFQAzAIwB2KSqn3Ns85cArq38+DKA/6Gqj/k9blMXRQF8q1w+fOqVuPrJ08JVyJw2CzjtfODpbwPHD+E5dOFTQ++zet8F2NlxFWa1Ha27/TlMxx+/+rlctw9gmwMiIiIianZptS0YAfBxVX1ERE4EsEdE7lfVJ23bHADwDlV9UUQuBLAJwNsiPGfh1Acgi7H8msddt7OmH1oFQepK+DurWh4/CDx2x/i6uoce7cf9W/YBY6N1j+00U+qDOaB2/V0e2wewzQERERERUa2Gp1yq6rOq+kjl378F8BSAbsc2P1DVFys/PgRgFlpINQDpPzZYEyi5FSjZsGN/zVoyABgcHsWGHfutHzyqWlarYtqnLwKA+OzXYe3yuH1i/V3Nc+dE4DEiIiIiImoxsayhE5G5ABYC+JHPZn8L4N897r9SRHaLyO4jR47EsUu5YBKABJbwD2g0DlhB3a7V5+CX6y/CxkvfMr42rbNcQql9IsS7ZWQFBrWj5mHc1t/lrX0A2xwQEREREdWKHNCJyAkA7gZwtaq+5LHNn8EK6K51+72qblLVHlXtmT59etRdyg2TACSwhP80j+Sm/fa+Xqsh+dpOLP/uUux651EcWH8R9t54Pja894zxAG/Pa8/D42d+crwlwnOYjtXDl9etv8tb+wC2OSAiIiIiqhWpbYGIlGAFc19T1S0e2ywAsBnAhar6QpTnK5qZnWX0hwze3Er4l9oEA0MjmLd6Oz50wntwQ/ttmDT66sSd7FUx3dbY3XeV9e8FK7B8Ybdjndk5AK4AANf1d3lsH8A2B0REREREtRrO0ImIAPgSgKdU9TMe28wBsAXAB1X1p40+V1GtWno6yqX2mtu8AhBnCf/OcgkQjLcauP3ls7B6+HIMlF8P10bjAWvs/BSlfUCY/dz6aD8Wr38Q83LcUJ2IiIiIKC5R2hYsAfBfAPbBalsAANcDmAMAqnqbiGwG8B4Az1R+PxJUfrPZ2hY0WmZ/8foHXbN73Z1l7Fp9Tv0d1nZiopW4nQBrj5nveAE5q2ACVgCdx+CUiIiIiMhLKm0LVHUn/IspQlUvB3B5o8/RDOqnOoZjXABk2qxKo3CX21uEXxEaBnRERERE1IxiqXJJ8TMuAHLuGmtNXQ2xgryN8601dgaKOHUx6SqYRTwmRERERNTcIhVFoeQYFwCxr6U7fhBW8rQyBdNRIAXwnwqadAPvRqehBjEpQmOKTc2JiIiIKI+YocuphgqVLFgBXPN4pR2BYz2drUBKUMPzJBt4mzRbN2VShMYUm5oTERERUR4xQ5djja6/825CfhBY24m3owvnjb4P2zDRd86+1izJqYtJrnOr3j+J7F/QMUkq60hERERE5IcBXTPyKpACAFDMwBGsL20GhlHTTLwanJhOXTQJZpJe59ZwEBzA75hwOiYRERERZYVTLpuRa4GUWlNlCJ+YVFsopRqwmUxdNJ1CaVzsJSf8jgmnYxIRERFRVhjQNaMFK6ym49Nmw6+zxEx5Yfzf9oBt+cJufGXRM3hoysfwi8mX4aEpH8NXFj3jmm0yDWaSXOcWN3tVyw079uM9Z3a7rmlMOutIREREROSFUy6b1YIVE5UvN853nYL5vHRBgPppkn29WLTvRgCDgAAzcAQz9t0IzD1p4jErwgQzzimZ7zmzG9/5yZFcrzdzm0Z5955+18I0SVbXJCIiIiLyw4CuFZy7xmpbMGwLOkplzLj4Uziw4CLr575eYOM6q6CKtAFam3XD8CAOffM6XPpvXfjsm57Gop9/Hjh+CD+c0oVPDb2vZi0eMBHMmARGeWJSvMW4xQQRERERUUw45bIVOKdgTptt/VzNtvX1WgHf8YMAtD6Yq5gpL+DMl+7H/D03jG87A0dwc2kzlrXtHN/OHswkvr6sr9fKQK7tbKiBuheTaZQNtZggIiIiIooBM3Stwj4F0+mBdbXZOw+H9WR8YlIvyjJUc3tZhnB9x12479UldVMoE11fVg1Eq/vu0kC9UabTKJOqrpk0tlsgIiIiKjZm6Mi7b53NgHbglpEVmClHXX8/A0dxYP1F2LX6nJqAINGqlm6BqK2BehRFKt7SqCSbvBMRERFROhjQkdW3zo20YwyCQ2NdWD18ObaNLcFh7fLYts112mPUwMheaXLx+gdrgw3PBurBAWqQLKdR+r7mGLVKu4W0jicRERFRFjjlkjyLpuDiW7FtdLFV8GPMGvjfMrICN5c21027HF9355j2WA2AGpnWF9iw26uBuleAaiiLaZRpNin3mvbaf2wQ81Zvb4opmGz6TkRERM2OAR1NrDd7oFLlctosK8hbsALLAXQf/BZmP7IBp+gRPC/Tcfj3L8Gpx3b5VsTEA+vGH7fRwCiw0qRXIHruGtfHK8J6MZPqmlF5rRMEUDMFE3APfng8iYiIiLLHgI4sXkVTXHrS4fC9E1Uy13a6PtzY8UM4NWKWJ7Cgik8g6hR7pqavN9TzmkqzSblbuwUnr+CnKJkvNn0nIiKiZseAjvz5FR5ZsMJz2uPhsZNDZXmc7FmfNhGMqtZtU1NQxad6Z9BjNZyp6evFyL1XYtLoq9bPxw9aP1f3J4I0m5Q7p8PWH2mLW/BTlMwXm74TERFRs2NAR/6CCo+4THv8nbZjqryKX0y+DIe1C7eMrMCGHR2BA/2tj/Zj5z1fwJ34BmZOPjp+X3vT8rAFVZwZJLfAEGgsUzPw72swtRrMVUwafdW6vRLQOacj/tkbp+M7PzkSOD0x7Sbl9umwi9c/GDr4KUrmi03fiYiIqNkxoCN/QYVHHNMeXxh7DU6UV/E6eRkAMEuOYkPpi3hl8CvA2ld8pyfu3b4J62QTplYKrsySo1hf2oy2EcG9o4uNpm+6ZZDcNJKpmTL4nO/tbtMRv/rQr8a388taRikiE5VJ8BMm85WHNXZZHk9TeTheRNQc+H1C1FpEPTIXgXcUmQ3gKwBmABgDsElVP+fYRgB8DsA7AQwA+GtVfcTvcXt6enT37t0N7RMlwNm8GxivgOkWlD239g+sdXZ+PO5/aM2pmNVW3+fu0FgXZq37udFuz1u93XMKYVW51N5QK4Kg/fTKdDl1d5axa/U5Rs+dtLCDAGfQCtQez6Df50keBj5FOl5ERZOHz3ia+H1C1BxEZI+q9oTZNkqGbgTAx1X1ERE5EcAeEblfVZ+0bXMhgNMqf94G4J8rf1NRGBQeAYDfg3vj8RqOKphVM9tecN3c63Y/XhmkdhGMqUb6T31zxwfwieEvjGcSAavx+uaOD2Atwk87zNv0RCB8RdKgzFfaa+waneKal+IuRVmTSFQ0efmMp4nfJ0Stp+GATlWfBfBs5d+/FZGnAHQDsAd07wbwFbXSgA+JSKeIvL5yXyoKn8IjTuI1RdPJZW3eq+UZmDpYf2q8Wp6BqR4P43Xl1Wv6YBxXKN9y0UqsuWcEV+s3MFNewGE9GZ/F+7HkopUA/NsB2BW9MIdf8JfmGrsoU1yjDnziuvJflDWJaWu1zArFrxWDG36fELWeWNbQichcAAsB/Mjxq24A9tH9ocptDOialVtvODcuzb+nXriutnokgJH2KZh64TrXhwhz5TWJwaD1GB/BpTvOdX3sMO0ATApzNJp9ylKa1SXDrJf0GsBFGfjEeeWf1TjrtWJmheLXisENv0+IWk/kgE5ETgBwN4CrVfUl569d7lK3tElEVgJYCQBz5syJukuUJecUzfJJwNDLwOjE9ETP5t8LVlgnpG165ySf6Z1BV14bbWgeht9juwWTjQZhUbJP1fvHGdSGfbwwBVaSzm6F2S7KwKeRK/+mGeVWrsbZipkVil8rBjf8PiFqPZECOhEpwQrmvqaqW1w2OQRgtu3nWQAOOzdS1U0ANgFWUZQo+0Q54JyiadKE22B6Z56vvMYVTIbNPn289zFcc+femiAh7gyHyeMFZUjTyG65becUZeBjev5llVEuqjx/vqk4WjG44fcJUetpOKCrVLD8EoCnVPUzHpttA/D3IvINWMVQjnP9XAsyCNJMtMKV17CD12qfPXuQEHeGw/Tx/ILaOPctyhTXKAMf0/Mvy4xyEbXC55uS16rBDb9PiFpLlAzdYgAfBLBPRPZWbrsewBwAUNXbAPwbrJYFP4PVtuBvIjwfUY1WuPIaNvtkVw0S4s5wRH08+3RDrzS8X3bLa0AWdYpr0MAnrmmSzDiZaYXPN6WDwQ0RNbsoVS53wn2NnH0bBfDRRp+DWoDJdEyHVrjyGib75KZ6POLMcER5PLe+SF7PEXRft6mKSQ3Y4pwm6XX82kQwb/X2pjx/o2iFzzcREVEcGm4snhQ2Fm8hhk3LQz9mgwFiXvlVuWwTGZ9uadddGfzG2bohSrPaMM3WvR7L675pNGaP87nDBLVs/psctkAgIqIiSauxOFFjxoMul351zqbjJgGaM0A8ftD6GQgX1OU0GPTLPnkFWc4m33EMYqM8nt+0QgEwrVyCCHDNnXuxYcf+msfNcqpinM/tPH5uwXhRqjgWLThiCwQiImpmDOgoXW5ZOadq03HTAO2BdfWP6wwQbeyD0g+d8GPcoLdN9MAzDQadAoJDowGxz2N5rR/bsGN/XdXLODQ6tdFruqFbJtE52M6yOEbcz20/fvNWb3fdJqnm63EFYEUMjtgCwVK0QJyIiMJpy3oHqMW4BV1O1abjfgGam2ogGOL26qC0v1Kg4/Khr9Y0NA98Lj/VQPT4QQA6ERz29bo+d3VAvPXRfuPHAqxB9K7V5+DA+ouwaunpuHtPf7jHTtGqpaejXGqvua2aSfQbbHvdt9QmGBgawbzV27F4/YOJvT6//Y7KKyiMO1A1Ot9CCHq/8ogFaeI/D4iIKD8Y0FG6vIKuKnvTcYMADcBEIFhHgY3za4Ig56B0phxtbH/dBASiRgNiw6A27sH21kf7sXj9g5EDp+ULu3HTJW9Gd2cZAiszV10r5jWo7j82iHmrt2PDjv14z5nd4/ftLJcAAV4cGE58YOq33676eq1zbW1n3TnnlGSwaBf3OVHE4Cit4DnPihiIExFROJxySemaNst97RwATJtdOzXRa1uvwO3cNd7TOR1TKJ2Dz8PahVkuQd1AeQamer0WLwGBqNGA2DCojXOwHffUOq/pmn6tGaoB2917+scDqcXrH8SxweGa7ZKcPhd6mqnhFOG0qjjGHYAVsT8cWyAUMxAnIqJwmKGjdJ27xsrC2ZXKwCX/AlzzeO3A12vbagbPacEKq0LmtNnuv7dltpyDz1tGVmBAO2puG9AO3DJ8aeBLquMVcFZuN8oWBDxWqMfwud1P5Cv6IbNVbpmqZW07sbPjKvxi8mXY2XEVzhv93vjzZj0w9cxamk4RRu102V2rz0kkII07O2WaWQzK8saVBfZjnGltQsxSEhE1LwZ0lK6aoEusv73aFJhsa7/PNY/Ds0ViJbPlHJRuG1uC1cOX49BYF8ZUcGisC6uHL8e/vnyW+Wt0C0TbSsDQK8DaTtwvH8F7O35Q82uBlYmqG9AaBrVxTuOLFDiFWPtXDfiW3/tH2HPC1fjrE34MgRXMrS9txqy2o2gTYFbbUawvbUbPS/cDyHZg6rcOST2ypl63pyXuqZ3O4KizXMKUUhuuuXNv3fkbtG4r6XVd9mCxWj01yeA5z9Ka4ktEROljHzoqlrCtBTbO95iuObsS8NVWfPPr59ZQrzP7fpZPAoZeBkaHxn890j4Fn5QP4/aXz4LAmlpYVdeLzLCdQlyV7CL1YAs6/j49CJ/bcj1m4EjdXZ/DdMxY+7NI/fDC8Dt+fsfk7ldX+u53lqKeE173D3ovgs6hJHsMRj1PTI5ZUapHFmVIdVW6AAAgAElEQVQ/iYjIrA8dAzoqDpNG5IZNyxMNEnyCm8W/uzXVptmmg1TfY+IXaK7tRG2YWiXA2mO+x0SPH4K43FchkLXHjF+HyTEIes3zVm/3elVY1rYTN5U2Y6pMBO4D2oHrhi/H5z51U6h9M5HW4NzvmGzYsd/3/PU7XgfWXxT4+yiiBIsm3wdJX2BIEgM8yhrPQSJvJgEdp1xScZisUXKbrnnGZda2Lmu6El1j41PYJM31YFsf7cfOe76AOwf+Dj+ffBnuHPg77LznC57T23yPSdCUyqC1fz7HRDzua7+9bu1Z+65Q6/WCpvgFrRv0m+65+7XnuU7b3f3a89xfawRplqD3OyZB52/Q9Ngkp89G+WyZrB8tavVItjGgrPEcJIoPq1xScZi2MViwYiJjFKICYaNNswP5VOucOSW9ioF7t2/COtk0nkGaJUexTjfhlu2TsHzhP7jex/OYBDVxd6s4al/751fBNOi+TgbVJYMaTAcFAUHVEq/bMoRtQ0tqfndTAmuU0myU7XdMvCpetolg3urtmFYuodQuGB6dyMPZj1eS1SejVOM0CQazLtLTqEbOIWZTKE5pfo8RNTtm6Kg4DCs+1migAmFsfAqbpFmo4PKhr9ZMBwSAqTKEy4e+6n0nr0qVnsH1QWvbB9ZZGVGvgjZ+xV5Mi+EYvLdRM0p+Wcs0KymmGUT4HRO38xcARlWhgNVeQoGTppZcj0mSxyzKZ8skc1jU6pGm51CzZFPSqKpK4RT1YghRHjFDR8VhmrmxM83umfJbT1b92+X3yyt3T+Oq98y2F4xu9818+fUTrE7BfOwO/wqmgP8xs9+vGli6bWvw3gZlbcJkjPwyuYlleR2S7gVnz8T4ZdmcvfTcigsNjymmdkzCo2vOd32upI5ZlD5/budBqU0wMDSCeau31zxWUXvcmZ5DaWZTksoExt1bM0mtkA0tYk9LmtAK52iRsCgKFYthxcdxIapeRtongwIsWRm4+Y2YOvhs/e3l12PqtT+pv4PfMfNr4u7cNunja/DeuhWweG/HD7DuNXdj6uBzwLRZePjUK3H1k6fl+j+pMIU4Gv3P1u2xS22CE6ZMwrGBYd/HSrLISdqcQe0rQyN1QW31eBdxYGNazMX0vY3z/IuryEySVVXjVORCOyZa5XU2I7536TApisIMHRWLM3MTVpTsXpCg9WQ5MfXCdRi590pMGn11/LaR9imYeqHHtFO/zJczw+Y61PN5DBNR1+vZOLM2Hzrhx7hBN2PSYOWYHD+IRftuxC57MN7XC2xs4CJCgoKyT+MFcPANzJx8FIcHuvDZe94P4COB/9m6ZWKCsmxVzXTF3Z45XLz+QWv6qI09O5VWZjZOphlMk/c2SiYsyUxgI1P8sgjWW2VtWZQsOmWrVc7RImFAR63BbYrfaedbP29ZGW2gHvd0zkazkEEWrLA+8LbHnuT32H6FSyqPN35fzyxZiPWNQYKOb9D0TYeawffGa4Hjr9ZuYA8WDQquuElyMOgXRJgWwLHvp9ecjTDrWoo6/TBI1LU+ec3gmQSiq5aejp33fAFX4xuYKUdxWLvwWbwfS5Z+pG7bKIO9JNdVmV5wyGqKZiutLSvixRBqrXO0KBjQUeswrHoZWlDgYyLO/XJjkuE0yHw9fOqVmL/nBpRtRVcGtQOPn3olFkXd5zDHt9HMbVCwGCH7GnUwGCUIuHzoq5ja5lUApzagc5s6s6xtJz4xqXd84H7LyArsCdF+oVmvuEfJPCZ9HgSeJzFdIFrevgvvKm0ez/DPkqNY374Zk9rPAFD7eFEGe0lmeU0vOGSVhWimTDc1J56j+cMql9Sa4qx66Vex0YtX9cgsq3E6GVSbvPrJ03CtowfbtcOX4+onT4u+H40c37Ai9MsLEqU/WdSKgiYFcJz7uaxtJ9aXNmNW21G0CTCr7ShuLm3GZ9/0dKjnrusRmODAN62KhVEqZiZ5HgSeJ0H9Ik08sK5mujYA62eX76YwlT+93rskK/+aVlXNKguRZvVjokbwHM0fZuioNTUyUPe60m045c83CxfnfsUhZObr8LFB9GNJTQ82AJA4Bj6mx9dElH55AZJqbB0mQHq1PMO1AM6r5RmYGrA/n5jUW9feoixDWPTzzwO4IvC505LmdLgomcckz4PA8yTO9b0G301BmbAw710WU5WdsspCNGumO4y8Tk+mWq18juZVpIBORL4M4F0AnlfV+S6/nwbgqwDmVJ7rn1T1/4vynESxCDNQtwdK5ZOAoZeB0cpA1zkV0mTKn9cga8vfAdIO6Gj9fbwCiKSnaIaU+MCn0SmVYR4X8A4WIxTTSauxtRuTAjjO/ZwpR90fNK4WHzHxCmY+3vsYrrlzb+AAw3Tg2OhanyTPA6/f9x8bxLzV2/HzKYfcp+E08l4aXNwIGuwFBaJprqvyOw+yXBPaimvLitRWoqjiDJhb8RzNs6hTLm8HcIHP7z8K4ElVPQPA2QA+LSIdEZ+TKLqgaXzOqUqDv5kI5qoanQrpN5hyC+b8Aoi0p2h6TBUt9PSLBSus9gZrj1l/2wNH0ybnNmk1tna1YAUmvfvzE/tdfh0mdUy1CgDZp/i67Odh7XJ/zDgK3MTIK5ipNjX3m6aaZpPsJM8Dv/NBARweO9n9lyHfS/u0yLWvvAcj7VNqN/D5bvKbepuXggpB50GSje+pXpTpyXmSZvN6k+dK83uP0hcpQ6eq3xeRuX6bADhRRATACQB+A2AkynMSxSIoM+MWKLmJ80q3nbQDOuY+vdCeOUyyXYCTTzZw+UJr/9IozhD7YwVpMDvolqX47JuexqLv/k/gXv/9jiUzUN3vgCyucz83d3wAN+htteul4lqzGCOvzJddzfRD2znzdnThvNH3YRuW1GwbNrtnIu4G5/bzwO33dreMrMD60ubaKbQh30tntuT2l8/Cyx0jNT0bTT539syAWwN6oPGMfqNZhzBTm5sxC5HXaY15CfTdhD1maWYZTZ+LrQaaW+TG4pWA7lseUy5PBLANwBsBnAjgUlXd7rLdSgArAWDOnDlnPvPMM5H2iSiytZ3wDJbsGmmc7dYou45YGaOG7tvgflUf3ytQitKcPc7m6wVp5F7HcL9NB12e2zfyvqUZMNuYVHR0a/btRgAcuOyVumM/oB1YPXw5to0tcb1fXprkPrzti5j9yAacokfwvEzHwbeuwqJlE2sZg1pOVCuWzmp7wei9jLMJt1slVadGj3eUBsemzdK9nj+PwZGXPDeEzmvjd5NjluZrMH2uOM53SleeGosvBbAXwDkATgVwv4j8l6q+ZN9IVTcB2AQAPT090SJMojiEyaI1mrWoyQ56PIfXlKgwmcNG9ytoPV6UfntxFmcoSCP3Oob7bZIZ8L1S28j7ltSaRXgPgIOuNjt/f2xwGKU2wUlTSzg2MOyf9Xng2rpjP1WG8IlJvXWFfKqCrlynMpDv68WifTcCGAQEmIEjmLHvRmDuSePvj7MBunOAt21sCfZMPc94MBkmWxL2GLhlBgCgXQRjqpGOX5Ssg1eWt00E81ZvD7UO03nOXnPnXlx951505zS4y3OWJq99LE2OWZpZRtPnYquB5pZ024K/AbBFLT8DcABWto4o39zW2LWVgPLrYLqWylV13dYl/2JWkt83eKrs1xmXWUGCsyVCkKD1eEEl/v3E2Xw97kbuaUlwv33XnkR532Lmt4YjaP2M2++HxxRTOybhwPqL8OkVZ3ivVfM4xjPFvb1DldfAyPk6znzpfiza+qfQymfu4W1fjGcNjeEa2TjXsgat3zNZj+N1HMdUQ7W38FsnFGUA7Xa8gHDrMAH3c7J6SSGv65PyPK0xr2sWTY5Z5PXPBkyfq9Br3SlQ0gHdrwCcCwAi8nsATgfwi4Sfkyg6t2IYy78AXHvAvXhGnM/jFyh6Ds5nW/t17hrgsTsa6zsVFHBE6QcXZ1CRowDFSIL77TvgcHnfRtqnYO0r70ll0b6dX9DWaEXH6u1ug8GvLHoGy7+7FF7Tp5+XLgisTJEbr4GR/XVU+/Z1y1FI5TM3f88NOPOl+0MXHvAMWAwvAsQ5IA4a/Ln1L7xfPopl9/5R3YWkKIPcoMAxymM7j5fbeeBXlCMoCMpjQY80A45GROljmVQxEpNjlmbQZPpceQ2YKR5R2xZ8HVb1yi4ROQTgRgAlAFDV2wD8I4DbRWQfrGm616qqR01sopxJcNpZw88TVEY/ynTEoLLkUfrBRSj/n+hjpSnB/fadSrOgsjai8r4NlGdgzSvvwTeHzgKQbmlwv6AsaDpQmOlCNdNU+3qB+270nqJcKmPGxZ/CgQUXea6R8RoY2V+HV98++3ROvyltvlNNG+iDGFcRj6BiLvZjUA1qx4+DY7p2lKl0QdPd3B671CYYGBoJNW3Sfrzmra5b4l/3Wu3CFObJQ+bLLq/TGqNKshiJyTFrpAhSo9O3G3muZizyQ5aoVS7/IuD3hwGcH+U5iMgmKKgyndbn7LXX3lHbnsEZcDQa5MbZHLyRRu4ZFPiok2CD9MABh+19O2/9g+gfqh1kprWGxi8oa6Sio+9A1G+96bTZNcfedGBkfx1effuc0zntA3t7oZNF6MJ5oyvqKm5u2LEfy9+Z7cULv8Gf/Ri4BbX2C0lJNmZ3Pna1WM6LA8MAzAb2pmuMgqqM+t3XVFxrNpu1IXSSawNNj1ls658ra4f9npcBGlVFrnIZt56eHt29e3fWu0FUTCYVDd2qLraVgMknAoMvZhv8xKWoFTEbEFQNsSrLSmdB1eJMqlwGDkQ9K9V6VJBt8HXs7LgKs9rqg7pDY11YMnTr+M/VynMPb/si5u+5AWVbAGSvuFmtSjlTjqKtczZw2vnA098evwjw8KlX4uonT8t8MG4/Br+YfBnaXGetRj/WppX8olQZbKQCZPWc7D82CEHtGRdX9ci0K1MWrXInUNwKjn7nq9dFrFaYJlnEczAJeapySURpMpnW55bBGBsGOl5jrRVsBkWtiGkqRDXEqiwrnQVd6Q662mx0NbqB6Yph2V/HhpdWYH3Hl1DG78Z/P6gduGVk4rjbM4mzH9lQE8wBExU3MYL6qYuP3TF+AWJiYG+9f2lOl3WqeS8HujDLLVMZw7E2zcxGKfoRdQpbUoPQNCtTptlHLcy+NJI1twtbsTTJffPb1u98zXNF0iTl6RwsEgZ0RM3EZFpfUatFmkj6NeZlOqdB4Jr1GprUpgglvNZy4nWcA/QtrDkPHj/1Sux58jSIywDuFD1ipQ0cZsoLgVMXGxngJXmle/wY9N0U+Vh77WeU6bDO241eUwOC7tvoe5FmZcq8BBFhBvXOvpSldqnrS1ltZRJnUGAScARt6xeIeq3PzNu6zKq4vmvSvoDRLJlABnREzca+zq0acGxZWR9wJJjByI0kX2NQ3740GQSuzbqGpk6CaxZdn8v2uIsA7FrmvunzMh0zcKTu9mdxsud6vOr7aDqwT+1Kt9uxPu187+8ew/10BkrVaoZu52/WFyzsnAHHK0Mj4wFH/7FBrLrrMfzDfU/g2MCw7+cwzax6nP0Howga1DfSlzKuoMAk4GikqA8A156aVUnNpojyvsb5XZPWBYxmywQm3baAiLJSDTi8WhhEaUNQFEm+RsMeYYkybIkQpTR4ZH291lpP0z6JjTw2YK0djbPVSEQH37oKg9pRc9ugduDwmZ+w1sy5qbyPpiXng3r71Yny3lR7azbQPsVkP4PaGCRdmj1saXznfh4bHK7LHg2PKV4cGA5sb5FmKfw4+w9G4TV47z82iHmrt+PjvY/59qUc8wiI4ggKTAIO03YrXi1UqpJ636O+r0GfYZOWEmm11jD+fsw5BnREzSoo4DDtgVdEbq+x0cbrTllPWbUPvodesSqU2uUxOA+6yNDI41WPwc3zgHs/Gv6xkwwsfSxadgUeP/OTeA7TMaaC5zAdj5/5SauATcAFCNOBvdGV7jjfG8OLHSb7GWYQltQFC5NBr9t+BvEaTIYKUmM6n93OMXsbCLdAKolBsN/gXeGdwaqeM0kGBSaPHWZb+/nqFYgCyfaNixrc+H2G3T43q+56DAvXfds1wEvrAkaaU5nTwCmXRM0qTMCRVq+9LDmnoMY1TTLLKavO1zH4G6tCafl1+a5QGmeRGrdj4OT12BlPl1207AqgUoF0RuVPzXN7TBNNdD1ZnO+N4cUOk/3MchBmMtWu0f3xup/v+rwYz+egNhBBgVRcwrSEcFM9Z5Kcemvy2Kb74fVZCFOlNYqonyu/z7Db56aanQbcp1gD8S0L8JpKmmWBsCQwoCNqVq2wRs5UnIPWMEU3YiyaYv9P6YdTrscMFLBCaZxZTb8+c0GP7XUe3PPhUGu+EhVwkcWkaIfRYDLO98bwu8dkP0MNwhIqVmQy6A3TdNxNQ4PJmKv52s+xxesfxLHB4cD72KdkJtEvL0yDLfs5k+RaYZPHNt2PrNaARg1u/Pb7mjv3Bt7feWHEtJef1/H1WyeXp/W2cWBAR9SsEq7yV0hhBq1hB4NBRTdivGru/E/Jq1Ji7iuUxnmRIexrdXtsr/tq5T/2DAvcxFlwwmQwOVCegamDz7rfbvrEht89JvsZOAiL+rnz+fybDHrd9rPUJjhhyiQcGxiuK5JS9zpMJDj9O0yGprrfcReZcAaWbse+XQRjqqk33TZ5bNNtgfSLVkUNbvz2u9qnMUjYbKC95+pz0oXvjVyK/pHFAOrPOb+sejXj2SwFwhjQETWrNKv85Y3XoCwooDAdDPplU2K8au78T+mwJtf3K1FxXmTwei/tvB47zH0z6FeYRNW1sIPJW4YvxSf0CzVtEwa0A7cMX4q1pk/awHdP2P0MHPBG+dwFfP5NBr1hBuaxBe8JzsbwCmLdAqnF6x9MrNx8KzXZTq21i+M5gWjBjdd+h50+GyYb+PC2L2L+nhusXp4CzMRR/O/2f8HomGLb2BIAtedcmKI0zXL+MKAjamatsEbOyW9QFhRQZLiOyI/zP6VbRlbUNqAGipF9jfMig9t72VYCJp8YvI7Q7b5uUs54ZtkD7F9fPgu/abManM+UF3BYT8YtIytw3+/OMg/ogES/e3wHYVE+dwGff9NBb9Bg0aQdg68EZ2OYBFJJrm9smXYrAVLpKxkzr3WZjWSnZz+ywQrmbKaK9b21bWjJ+G324jjNtE7ODwM6ImoufoOyax6f2MYtoIhzSmaMV82d/yltG1sCDAPXd9yFGTharOxrXAP9KMGh877SNjHd0i7ljGfqBT9s5/IPp3ThU0Pvw5KhW2s26S7awCfK5y7E5395+y4sn7wOmHIImDwLaF8DIPr5HCk7m+BsDJNAKunBc56zKWn05ity3zS3ixeNHC+v5QYz5YXan1MojpM3DOiIqLkEDcr8Aoo4p2TGeNXc7T+l+9vfgXPe/fe5/488UVGCQ7/qp0AmGc9UryY7XvMMHMHNpc3AMManLpkMfNIY0IYS5XMX95RsA5GzswGfhSjvT9hAqpUGz3amgVaj70Uj50huPpcOjQbnz8t0zMCRutsP68nj/06rOE7esA8dETUXwybbNYIakZv014qxz1/SzZJbXk56MqbZQNrtXC7LEK7vuMv4HEur2XQoUd7LOD//hgKzsxH6zCX9/lSnil5z515MntSGk6aWxs+h95xpFaYI01C6qEx6uEV5L0wz+Ln6XMbk4FtXYVBre64OaAf+37bLPL+3kupLmTfM0BFR9uIsMx7lCn3Q1CXT9TkxriNKaqoXVeRgvWmqV5M9ztkZOIoD6y+yfujrBTYGfy6zXPvnyvleVoOhqJVrE6wm6ZudDZEZ9MvEJPn+OLNTxwaHUS61Y+OlbwGAuszVqrsewz/c9wSODQw3TbbEJNCK8l6YZvBz97mMwaJlV+BhoFLl8iiely4cPHMVblp2BW7KeucyxoCOiLIV9zSmqOtJokzJTErGjbApPamtE4pjemHlQsx/DR7E4Y4u3DKyYny6JpBOs2/7fsTSPiSjz7/vdMUHXAr42Iq1BE35S3JtZlB2yqShdFGZBFpR3gvTKa1Bz5XX6ZhBFi27Alh2BQBgRuUPccolEWUtiWlMC1ZYBVDWHrP+jivoCZqSZSrsNKoEp3pFFvQaTH5/8zzrTwPTyshQ1OmF1UDp+EG0CTCr7SjWlzZjWdvO8c1TqSRn2w9AJwK26rkT52cn7s+/je+06oDMYFBQ5fU+xPH++AUNYYIUr6mJRWIyVTrKe2E69d7vuZpxOmarY4aOiLKV4DSm2MVZTc4kc5DXYxT0Gkx/P/ibicdmFjJZUacXugRK9vLhkdb+mUzBDmo1EudnJ+Henp7Z2YDMYFAmJsliJUHZqTgbSscpKDtlkr0ymSodRwPvsFk0v+dKusBKnrN/ed63KBjQEVG2sprG2Ki41lp5DUS3/J31O/tAMa/HKGgw3cjvvbal+EWZXugREM2UF9AdZZBkOkUyKGCL+7OTxVrLgHXBQUFVkmszgwKUuBpKxyloimoj7QHCBlpprpNdvrAb3Qe/VVlvdgTPy3QcfOsqLFp4Aa65c6/rfYIKrIQ5Jnlur5DnfYsqUkAnIl8G8C4Az6vqfI9tzgbwWQAlAEdV9R1RnpOImkyCTXFzzS9D4BzEZn2MvDImnoPpg9a0SajH7w/V/u0n6yxkqwo65zwCpbbOWdh1zTmNP2/QRQCnoIAt6c+O/bNRPsm6LaixvamAzGCYrI9fwBG1pQHgH6DE0VA6TkHZqaSLiaS2TravF4v23QhgEBCrNcmMfTcCc0/CzM6uxAqs5LkYS573LaqoGbrbAfw/AL7i9ksR6QTwBQAXqOqvROSUiM9HRM0m4WlMueU1EK0aHgTu+TCwZaW17RmXAU9/O/1j5Jcx8X0NHsFc9X6B93dsS+kK+lxGDZSMLxJ43B60H0l+v6Q5ZdgnMxgl6xNHxsIvQImroXScgqaoJllEJlU+F0dWLd0Ra4GVRrcNI85zpmneWxeRAjpV/b6IzPXZ5DIAW1T1V5Xtn4/yfETUpHJQMj51bgNRJ638Z3v8IPDYHZn0RvPNmIR5DU72wXbQ/dtKwNArVravVQL9PPH7XEYJlBq5SOAV2IfZD2cT+QfWTVwoiXJO5WjKcKNZn7QzFqllp1xUAwOvS03V7JRpe4Dc8rk4EuYigD2QahPBqNYfObdjEufxi3uKZNO8ty6SXkP3BgAlEfkugBMBfE5V67J5IrISwEoAmDNnTsK7RESUAzUD0YAsFZDdejK/jIlzMO2XlYPUD6Cd97dPWSufBAy9PJH1YJGU/Gn0QozpRYKgzF/Y/Yi7/UcTTBlu5oyFnTMwcLJnp5IsIpM0exD2wyldmIEj9RtVLo4ETcO1HwO3YM7rmMR5/OK+4FDk9zZI0gHdJABnAjgXQBnAD0XkIVX9qX0jVd0EYBMA9PT0+I0IiIiaR3Ug6hxoeslicBiUMbEPpjfO99h2ttU+wo3XYHzj/NopbACLpDQLk4sEcWZmTdfnBQkzZVjaEskwxzUNLfGMhXNq7WnnZzJ13C0wqHIW8UmzcEmcnEHYp4beh5tLm1GWoYmNQk6L9jpe7SIYU/U9JnEev7gvOBT1vQ0j6YDuEKxCKK8AeEVEvg/gDAA/9b8bEVELcQ5ipW1iuqVdXOvJTMrCm2RM4ixAkXWrhpwMRI33My/75cfkIkGc4j6nTKdNx5RhjnMaWiwZC69z0C0juvtLE/dLMevuFQAIgF2r64v4ZDk1tFHOIGzb2BJgGLi+4y7MwFGj7wev4zWmigPrLwq8f1zHL4kLDkV8b8NIurH4vQD+REQmichUAG8D8FTCz0lEVDz2Zuh/fltiDYwDGzG77dfFt1pZNoj1t9daPpNtg3gFr2kUSXE7Rru/FP6YpcX0vQzbyD5pCTbo9hX3OeU838uvs/5AAGmv377RhuYOQY3ETZg2q67jdw4GrTEEYjsmQWZ2lrGsbSd2dlyFX0y+DDs7rsKytp1NsXaqyi0I2za2BH/86ues/1eueTz0d3GSzehNmDRtb3WiLvNiQ99Z5OsAzgbQBeDXAG6E1Z4AqnpbZZtVAP4GwBiAzar6Wb/H7Onp0d27dze8T0RETSGpzEsj0yKz4DYNtVROpzCM1zFyiuuYNfpem7yXWR7P6vNnnfF0OwZtJWDyifG3GvBs2yHW4DqCeau3ez1yqOxJrPzOwcB1tVXRj0mQh7d9EfP33FAz/XBQO/D4mZ/EomVXJPrcaVm8/kHXbFZ3Z9k1C+nHbc1hudRuFuzHJA+VUbMiIntUtSfMtlGrXP5FiG02ANgQ5XmIiFpOUaadJSXLdhZhj0UcxyxKoQ6T9zLu9WMm3F5jFlVb3YrwJFV4J+6G5ja5qtTndw6GWWMIpJJ1X/TzzwP2tWQAyjJk3Y7mCOjiLPiRp7VmzTpFMm5Jr6EjIqI8SXCgGbus2lmkORCNEmiZvJdZBvJZBpNOziI+SRXeSbChea4q9fmdg2HWGKYx1RYozoWsCOIOwhhIFUvSa+iIiChPslq/VCRux8gprmMWZaBp8l5muSYxr4PpJPcrzvWkDpHXvcXJ7xx0OwY9f5vIMQkU9fwPWn+ak/Wpyxd2Y9fqc3Bg/UXYtfocBmQthBk6IqJWkuVUxqJwO0Yma75M1sRFyZiavJcJZowC5TUrnPR+JZhhXt6+C8snrwOmHAImzwLa1wDI4DMcdA5mlWV3inL+B02Ljru/YSsqYrXenIlUFCUJLIpCRJRz/M/Xm2nxkTSLlWT1vmVdkCXKfuXxXM/r8cy7pIoPmRaayuM5lSWez55MiqIwoCMianUmAwz+5+uvkSqirTDAi/M1pvVYeT3X81ypthnP5aCKpSYVTfN6TmUpz+dzxlKrcklERAVnOl0oTwUu8qiRdVl5mZaWpLheY9zT2/z2K6/nel7XJDbr1MOgqbkmU3dNz6miBsgm+x10Phf1GKSMRVGIiFqZ3wDDTV4Hk3mRdPGRnBRfyIzp+RpFXs/1LKExsZYAACAASURBVAvc+EnzvUlTUPEhk+JEJueUW9P2rR8Bbp6X78+/X7N5N37ns+ljtTAGdERErcx00JrXwWReJFlFNMzgptkDvjSDrLye63mtVJvXADiqoIqlJhVNTc4ptwB5bLjSaiPHwY1pYO93PjfrRYIEMKAjImplpoPWvA4m8yLBcvWBg5tWuJqdZpCV13M9yXMsirwGwHFYsMJaz7X2mPW381gH/b4qjmyenTO4ycMFHdPA3u98btaLBAngGjoiolZmWs6bbQ+CJbUmLmhwk9c1X3FKs/1Clud60LqhPK67zLI1RlRprdMyOae81uY52dea5WENo9d+S5sVaJqcz0m3Fmmi9XmscklE1Oqa6D+1phZUDc6k2l6RNfv5WuRKiEV8b/p6MXLvlZg0+ur4TSPtUzDp3Z/PX1sNN422T0hKmP12nM9bH+3Hhh37cfjYIGZ2lrFq6elWU/QkPwsF+JyxbQEREVGzCRqA5GVAR9HwfUzVwM1vxNTBZ+tvL78eU6/9SQZ7ZGMPkMsnAUMvA6NDE79vKwGTTwQGX4T7xRwgkws69v2WNkBH67epnM9bH+3HdVv2YXB4YptyqR03XfLmiaAuiYsEBficsW0BERFRkkx798UxIAmarlXkKW80geuGUjVl8Dmj21PlnIroFuAN/sb/MbJYw2jf77Wd7ttUzucNO/bXBHMAMDg8ig079lsBneH0Ys9sn8fzh7495xjQERERmTBZq5Jm3zSub8y3sIF90uuG8iyDKZuHx07GrLaj7rcn+swNsH/+N84PDubycEEn4Hw+fMx9aqbX7X6c2b7+Y4O4bss+AKgP6prsc8Yql0RERCZMSmmnXXY7bLU9SpdJBdI4qmvmodqhqYyqtG7u+AAGtKPmtgHtwOaODyT6vJ7Cvne+maQcVT8NOJ9ndpZd7uR9ux+3bN95o9/D2+99R/3xzGsV2wYxoCMiIjJhMlWnyab1JKaIAYgJk8A+aluCoravyKjn2FsuWok1uhKHxrowpoJDY11YoyvxlotWJvq8rkzeO882EbPzdUEn4HxetfR0lEvtNXcpl9qxaunpxk/lzOota9uJ9aXNmIEjqDueeW3/0SBOuSQiIjJhMlWnyab1JCIv5daT1EhvrkZfe1HbV2R08cOaivcRXLrj3OB1V2FEmTZq8t4Vac2sz/lcPc6h1r0FmNlZRr8tqPvEpF5MlaHajezHM4/tPxrEgI6IiMiEyUCqSIOurBQ1ADERJrCPa/1YUbPCnn3X1MraJriebvnC7sYDOLuoFydM3rsmWjMb1/FftfT0mjV0M6V+bSSA/H8WGsApl0RERCZMpuo02bSeRBQ1ADERtF4nzmmSnlPxcp4VdjtGVccPAls/Atw8L9/TcqNOGzV977hmtma69vLvLsVXFj2D7s4yBMDzMt39Pnn/LDQgUoZORL4M4F0AnlfV+T7bLQLwEIBLVfWbUZ6TiIgocyZTdZpoWk8iWmFaalA2Jc4sZVGzwjXHyOV8GBueqOqY12m5US9OFOm9y0MTeZeM6KJ9N2JX9aJZ3yvFOZ4RRc3Q3Q7gAr8NRKQdwM0AdkR8LiIiImo2TVZtzpNfNiXOLGWRs8LVYwQJ3jaFginGomZH03zvohQiykvhHa8LIfd82HpdD6wDzrismJ8FQ5EydKr6fRGZG7DZlQDuBrAoynMRERFRE2qitUANiztLGSUrnIfMi+d6Ooe8TcuNI8OWRkY/6lq/vKx79Xr/tdK64PhB4LE7mjaIs0t0DZ2IdAP4cwC3Jfk8REREVGCtvhYoL1nKvGRe/NbT2eVtWm5RsqNR1/rlZd1rmPc/j5ncBCRd5fKzAK5V1VER7/S5iKwEsBIA5syZk/AuERFRIeUhc0CUhLxkKfOSeXEej/JJwNDLwKitBL0z4DX5fkjyu6QIa2ajBmR5WffqlhF1k7dMbgJEVaM9gDXl8ltuRVFE5AAmJkJ3ARgAsFJVt3o9Xk9Pj+7evTvSPhERUZNxThECrAFdHq9+ExXV2k4AbuNCsbKnWfILwty+H9pKwOQTgcEXa7cP813S7BePNs73CMhmV9YwBsjT97H9vZK2iemWdmFfV86IyB5V7Qm1bZIBnWO72yvb+Va5ZEBHRER1og5AqLiadXCdl9eV5YA4rmPg9f1gVw04vKpoVl9jnoKVpDTyGp3v1WnnA09/2/vnPFS9BAr93pkEdFHbFnwdwNkAukTkEIAbAZQAQFW5bo6IiOKRlzUblK6oxRvyKu3XZR+Ml0+ybht8sX4qo1swl9RavjiPQZjvgerU0aDvkrSnnWYR2JtO8XV7r+zFRkzfy6Rec16mLmcgcoYubszQERFRHWboWlOzvu9pvi63rEUQaQd0LNkBcZzHIEyGDoBVqMRr/VfledOcdlqUjFLQe2XyXhblNeeASYYu0SqXREREschLFUBKV7NmZtN8XW4ZpyA65l1xNEr/Mrs4j4FJVcyg75KoveRMRK02mZag98rkvSzKay4YBnRERJR/RSkHTvFKc3CdpjRfVyMBktd+xNnWIM5j4Px+KL8OaO+o3aYatAV9l6R58agoFyyC3iuT9zLr1xzXBYmcSbptARERUTyKUA6c4hVHo+Y8SvN1hW3S7bUfQUVTGl1fFvcxcH4/+K3T8vsuSXMdVl7K/wcJeq9M3sssX3OzrskF19ARERFRnuWlGmTc0npdQWvovMr7h7nvuAbXlzXrextWkdaTBb1XYd/LLF9zwdbkptq2IG4M6IiIiIhi5FXlMiiICltsJKcD4kJoxaA2q9ec5z6LLlJrW0BEREREOdfodOUw65qaYQpsllpxKnlWr7koU1wbwKIoRERERFTPa6Ar7WBxIiqcJq6WzAwdEREREdXzKnbBII6SxMbjxhjQEREREVG9Jh4AU04lXYmySae4MqAjIiIiInd5HQC3YjGRVuDXeJzvrycGdERERERUHE3cT6zlZd14vKBYFIWIiIiIisMvi5OGvl6rpcPaTuvvvt50nrcVeBXiaYJKlEliQEdERERExZFlFqeaHTx+EIBOZAebLajLKmht4kqUSWJAR0RERETFkWUWJ+vsYBqyDFoXrLCqqE6bDbbGCI9r6IiIiIioOLzaKaSRxWmFNV5ZFybJayGeHGOGjoiIiIiKI8ssTius8WqFoLXJMENHRERERMWSVRYny+xgWqbNqky3dLmdcokZOiIiIiKiMFphjRcLkxQOM3RERERERGE14xovZ6P2My4Dnv42G7cXBAM6IiIiIqJW5dao/bE7mi/z2MQiTbkUkS+LyPMi8rjH7/9SRPoqf34gImdEeT4iIiIiIopRK7RiaHJR19DdDuACn98fAPAOVV0A4B8BbIr4fEREREREFBdWtSy8SAGdqn4fwG98fv8DVX2x8uNDAFgeh4iIiIgoL1qhFUOTS7PK5d8C+He3X4jIShHZLSK7jxw5kuIuERERERG1MFa1LLxUAjoR+TNYAd21br9X1U2q2qOqPdOnT09jl4iIiIiIqBVaMTS5xKtcisgCAJsBXKiqLyT9fEREREREZKAZWzG0kEQzdCIyB8AWAB9U1Z8m+VxERERERLnS1wtsnA+s7bT+7uvlvlDsImXoROTrAM4G0CUihwDcCKAEAKp6G4A1AE4G8AURAYARVe2J8pxERERERLnn1t/tvqusf6edDcvTvlDsRFWz3ocaPT09unv37qx3g4iIiIiocRvnW4GT07TZwDWuLZxbY18oFBHZEzYRlmaVSyIiIiKi1pCn/m552heKHQM6IiIiIqK45am/W572hWLHgI6IiIiIKG556u+Wp32h2DGgIyIiIiKKW576u+VpXyh2LIpCRERERESUIyyKQkRERERE1AIY0BERERERERUUAzoiIiIiIqKCYkBHRERERERUUAzoiIiIiIiICooBHRERERERUUHlrm2BiBwB8EzW++GiC8DRrHeihfH4Z4vHPzs89tni8c8Oj322ePyzxeOfnbwc+99X1elhNsxdQJdXIrI7bC8Iih+Pf7Z4/LPDY58tHv/s8Nhni8c/Wzz+2SniseeUSyIiIiIiooJiQEdERERERFRQDOjC25T1DrQ4Hv9s8fhnh8c+Wzz+2eGxzxaPf7Z4/LNTuGPPNXREREREREQFxQwdERERERFRQTGgIyIiIiIiKigGdCGIyAUisl9EfiYiq7Pen2YmIrNF5Dsi8pSIPCEiH6vcvlZE+kVkb+XPO7Pe12YlIr8UkX2V47y7ctvrROR+EXm68vdJWe9nMxKR023n+F4ReUlErub5nxwR+bKIPC8ij9tucz3fxXJr5f+CPhF5a3Z7Xnwex36DiPykcnzvEZHOyu1zRWTQ9hm4Lbs9bw4ex9/zu0ZErquc+/tFZGk2e90cPI79nbbj/ksR2Vu5ned+zHzGmoX97ucaugAi0g7gpwDOA3AIwMMA/kJVn8x0x5qUiLwewOtV9RERORHAHgDLAawA8LKq/lOmO9gCROSXAHpU9ajttlsA/EZV11cuapykqtdmtY+toPLd0w/gbQD+Bjz/EyEifwrgZQBfUdX5ldtcz/fK4PZKAO+E9b58TlXfltW+F53HsT8fwIOqOiIiNwNA5djPBfCt6nYUncfxXwuX7xoReROArwM4C8BMAP8J4A2qOprqTjcJt2Pv+P2nARxX1XU89+PnM9b8axT0u58ZumBnAfiZqv5CVYcAfAPAuzPep6alqs+q6iOVf/8WwFMAurPdK4J1zv9r5d//CuuLj5J1LoCfq+ozWe9IM1PV7wP4jeNmr/P93bAGYKqqDwHorAwMqAFux15Vv62qI5UfHwIwK/UdaxEe576XdwP4hqr+TlUPAPgZrPERNcDv2IuIwLqI/fVUd6qF+Iw1C/vdz4AuWDeAg7afD4EBRioqV6UWAvhR5aa/r6S6v8wpf4lSAN8WkT0isrJy2++p6rOA9UUI4JTM9q51vB+1/6Hz/E+P1/nO/w/S9d8B/Lvt53ki8qiIfE9E/iSrnWoBbt81PPfT8ycAfq2qT9tu47mfEMdYs7Df/QzogonLbZynmjAROQHA3QCuVtWXAPwzgFMBvAXAswA+neHuNbvFqvpWABcC+GhlagilSEQ6ACwDcFflJp7/+cD/D1IiIv83gBEAX6vc9CyAOaq6EMD/BeAOEXltVvvXxLy+a3jup+cvUHsxj+d+QlzGmp6butyWq/OfAV2wQwBm236eBeBwRvvSEkSkBOsD9jVV3QIAqvprVR1V1TEA/wJO9UiMqh6u/P08gHtgHetfV6cXVP5+Prs9bAkXAnhEVX8N8PzPgNf5zv8PUiAiHwLwLgB/qZWF/pWpfi9U/r0HwM8BvCG7vWxOPt81PPdTICKTAFwC4M7qbTz3k+E21kSBv/sZ0AV7GMBpIjKvctX8/QC2ZbxPTasyd/xLAJ5S1c/YbrfPVf5zAI8770vRichrKguEISKvAXA+rGO9DcCHKpt9CMC92exhy6i5QsvzP3Ve5/s2AH9VqXj2dlhFC57NYgeblYhcAOBaAMtUdcB2+/RKoSCIyP8B4DQAv8hmL5uXz3fNNgDvF5HJIjIP1vH/cdr71wL+G4CfqOqh6g089+PnNdZEgb/7J2W9A3lXqbT19wB2AGgH8GVVfSLj3WpmiwF8EMC+asleANcD+AsReQusFPcvAVyRze41vd8DcI/1XYdJAO5Q1f8QkYcB9IrI3wL4FYD3ZbiPTU1EpsKqqms/x2/h+Z8MEfk6gLMBdInIIQA3AlgP9/P932BVOfsZgAFY1UepQR7H/joAkwHcX/keekhVPwzgTwGsE5ERAKMAPqyqYQt6kAuP43+223eNqj4hIr0AnoQ1FfajrHDZOLdjr6pfQv3aaYDnfhK8xpqF/e5n2wIiIiIiIqKC4pRLIiIiIiKigmJAR0REREREVFAM6IiIiIiIiAqKAR0REREREVFBMaAjIiIiIiIqKAZ0RERUeCLycuXvuSJyWcyPfb3j5x/E+fhERERRMKAjIqJmMheAUUBXbdrroyagU9X/03CfiIiIEsOAjoiImsl6AH8iIntF5BoRaReRDSLysIj0icgVACAiZ4vId0TkDgD7KrdtFZE9IvKEiKys3LYeQLnyeF+r3FbNBkrlsR8XkX0icqntsb8rIt8UkZ+IyNek0iWbiIgobpOy3gEiIqIYrQbwP1X1XQBQCcyOq+oiEZkMYJeIfLuy7VkA5qvqgcrP/11VfyMiZQAPi8jdqrpaRP5eVd/i8lyXAHgLgDMAdFXu8/3K7xYC+CMAhwHsArAYwM74Xy4REbU6ZuiIiKiZnQ/gr0RkL4AfATgZwGmV3/3YFswBwFUi8hiAhwDMtm3nZQmAr6vqqKr+GsD3ACyyPfYhVR0DsBfWVFAiIqLYMUNHRETNTABcqao7am4UORvAK46f/xuAP1bVARH5LoApIR7by+9s/x4F/78lIqKEMENHRETN5LcATrT9vAPA/xCREgCIyBtE5DUu95sG4MVKMPdGAG+3/W64en+H7wO4tLJObzqAPwXw41heBRERUUi8YkhERM2kD8BIZerk7QA+B2u64yOVwiRHACx3ud9/APiwiPQB2A9r2mXVJgB9IvKIqv6l7fZ7APwxgMcAKIBPqOpzlYCQiIgoFaKqWe8DERERERERNYBTLv9/9u48PM+yzvv/+8zWJl2S7m22ltJSSndaWnaRRRAVUBARcBRFcNwHZX7qjDyK+rgwo4/O+MyM4zgzz4Aiu4AoI6iojG1paWnZ9zZL9zbpkj33+fvjurN1b9PkzvJ+HYdHcl/Xlev+pkTIp9/zOr+SJEmS1E8Z6CRJkiSpnzLQSZL6jPQGI7tDCOXH8lpJkgYqn6GTJB21EMLuTi8LSLbrb02/vjHGeEfvVyVJ0uBhoJMkHRMhhDeB62OMjx3kmpwYY0vvVdU/+eckSTpcLrmUJPWYEMLXQwg/DyH8LISwC7g2hHBaCGFpCKEmhLAhhPCDTnPickIIMYQwJf369vT5X4UQdoUQ/hxCOO5Ir02ff3sI4eUQQm0I4R9CCE+GED50gLoPWGP6/JwQwmMhhO0hhI0hhL/uVNOXQwivhRB2hhBWhBCKQwjTQghxr/f4U9v7hxCuDyH8If0+24G/DSFMDyH8LoSwLYSwNYTwXyGEwk5fPzmE8EAIYUv6/PdDCEPTNc/sdN2kEEJdCGHM0f+TlCT1VQY6SVJPezfwU5Lh3T8HWoDPAGOBM4CLgBsP8vVXA18GRgPrga8d6bUhhPHAXcDN6fd9A1h8kPscsMZ0qHoMeAiYBJwA/D79dTcDV6SvLwKuBxoO8j6dnQ68AIwDvg0E4Ovp9zgJmJr+3ggh5AC/BF4lmbNXBtwVY2xIf5/X7vVn8miMcdth1iFJ6kcMdJKknvanGONDMcZUjLE+xvhUjHFZjLElxvg6yeDutxzk6++JMa6IMTYDdwDzj+LadwKrY4y/SJ/7HrD1QDc5RI2XABUxxu/HGBtjjDtjjMvT564HvhRjfCX9/a6OMW4/+B9Pu/Uxxn+KMbam/5xejjE+HmNsijFuTtfcVsNpJGHz/4sx7klf/2T63H8CV6cHqQN8APivw6xBktTP5GS6AEnSgFfR+UUI4UTg74GFJBup5ADLDvL1Gzt9XgcMP4prizvXEWOMIYTKA93kEDWWkXTG9qcMeO0g9R3M3n9OE4EfkHQIR5D8JeyWTu/zZoyxlb3EGJ8MIbQAZ4YQdgDlJN08SdIAZIdOktTT9t5961+AZ4FpMcaRwC0kywt70gagtO1FuntVcpDrD1ZjBXD8Ab7uQOf2pN+3oNOxiXtds/ef07dJdg2dk67hQ3vVMDmEkH2AOv4fybLLD5AsxWw8wHWSpH7OQCdJ6m0jgFpgT3rzjoM9P3esPAycHEJ4V/r5s8+QPKt2NDU+CJSHED4ZQsgLIYwMIbQ9j/dj4OshhONDYn4IYTRJ53AjyaYw2SGEG4DJh6h5BEkQrA0hlAGf73Tuz8A24H+HEApCCPkhhDM6nf8vkmf5riYJd5KkAcpAJ0nqbZ8DPgjsIumE/byn3zDGuAl4H/BdkiB0PLCKpAN2RDXGGGuBC4DLgc3Ay3Q823Yb8ADwOLCT5Nm7oTGZEfRR4Eskz+5N4+DLTAH+F8nGLbUkIfLeTjW0kDwXOJOkW7eeJMC1nX8TWAs0xRj/5xDvI0nqx5xDJ0kadNJLFauBK2KMf8x0PT0hhPD/gNdjjF/JdC2SpJ7jpiiSpEEhhHARyVLFBuCLJKMJlh/0i/qpEMJU4FJgTqZrkST1LJdcSpIGizOB10mWPF4EXDYQNwsJIXwTeAb43zHG9ZmuR5LUs1xyKUmSJEn9lB06SZIkSeqn+twzdGPHjo1TpkzJdBmSJEmSlBErV67cGmM82Hiddn0u0E2ZMoUVK1ZkugxJkiRJyogQwrrDvdYll5IkSZLUTxnoJEmSJKmfMtBJkiRJUj9loJMkSZKkfspAJ0mSJEn9lIFOkiRJkvopA50kSZKkwWXNXfC92fCVouTjmrsyXdFR63Nz6CRJkiSpx6y5Cx76NDTXJ69rK5LXAHOvzFxdR8kOnSRJkqTB47GvdIS5Ns318PitGSmnu+zQSZIkSRqYWhph41qoWgmVK5KPO6v2f21tZe/WdowY6CRJkiT1f6kUbH8tCW1tAW7jWkg1J+eHT4CSRVC3FRpq9/36wtLerfcYMdBJkiRJ6n92b+4a3qqf7ghqucOgeAGc9nEoWZgEuZHFEMK+z9AB5ObDebdk5vvoJgOdJEmSpL6tqQ42rO60dPJpqF2fnAvZMP4kmPXujvA2bgZkZe//Xm0bnzx+a7LMsrA0CXP9cEMUMNBJkiRJ6ktSrbDlxU7dt5Ww+XmIrcn5wnIoXQhLbkgC3KR5kDfsyN5j7pX9NsDtzUAnSZIkKTNihJ3VULWiI7xVr4LmPcn5IYVQcjKcdVO6+7YQho/PbM19jIFOkiRJUu9o2Jk861a1Mlk2WbkCdm9MzmXlwsQ5sOCajqWTo6dClpPWDsZAJ0mSJOnYa22GTc92DW9bXwZicn708TD1LR2dt4lzIGdIRkvujwx0kiRJkronRtjxRhLc2kcGrIGWhuR8wVgoXQRzrkiWUBafDAWjM1vzAGGgkyRJknRk6rZ3HRlQtRLqtyfncobCpPlwyvVJeCtZBEXlycgAHXMGOkmSJEkH1tyQdNs6B7gdb6RPBhh3Ipx4ccdzb+NnQnZuRkseTAx0kiRJkhKpFGx7tdOukyuS5+BSLcn5EcXJyICFH0wCXPECGDIiszUPcgY6SZIkabDatalreKteBY07k3N5w5PAdvqnOjYuGVmc2Xq1DwOdJEmSNBg07oYNq7sO7N5ZmZwL2TBhVnrTkvTSybHTISs7szXrkAx0kiRJ0kDT2gJbXuw6sHvLCxBTyfmiyVC+BEo+nh4ZMBfyCjJbs46KgU6SJEnqz2KE2squ4W3DamiuS87nj0pC28x3diydHDY2szXrmDHQSZIkSf1JfQ1UP911YPeezcm57Lyk23byX3SEt9FTHRkwgBnoJEmSpL6qpSnZZbLzyIBtr3ScHzMdpp3XEd4mzIacvMzVq15noJMkSZL6ghhh++tdw9vGNdDalJwfNh5KF8G896VHBpwM+UWZrVkZZ6CTJEmSMmHP1q7hrWolNNQk53ILYNJ8WHJjx66ThaUundQ+DHSSJElST2uuhw3PdA1wNeuScyELxs2Eky7pCG/jToRsf1XXoflTIkmSJB1LqRRsfbnrwO7Nz0OqJTk/shRKF8IpH0nC26R5MGR4ZmtWv2WgkyRJkrpj54au4a16NTTtSs4NGQklJ8MZn+nYuGTExMzWqwHFQCdJkiQdrsZdUL2q09LJlbCrOjmXlZPsMtm2aUnJIhgzDbKyMluzBjQDnSRJkrQ/rS3JUsnOA7u3vAjE5Pyo42DKGR3hbeIcyB2a0ZI1+BjoJEmSpBihZn06vKWHdlevhpb65Hz+6CS4zbqsY+lkwejM1ixhoJMkSdJgVL+jI7i1/W/PluRcztBko5JF13WEt1FTHBmgPslAJ0mSpIGtpRE2Ptt145Ltr6VPBhh7Akx/W7J5SckimDALsnMzWrJ0uLoV6EIIFwHfB7KBH8cYv7XX+Q8BtwFV6UP/GGP8cXfeU5IkSTqgVAq2v94R3qpWwsa10NqUnB8+EUoXwYJrkvBWPB+GFma2ZqkbjjrQhRCygR8CFwCVwFMhhAdjjM/vdenPY4yf7EaNkiRJGmzW3AWP3wq1lVBYCufdAnOv3Pe63Vu6hreqldBQm5zLHQbFC+DUv+zYuGRksUsnNaB0p0O3GHg1xvg6QAjhTuBSYO9AJ0mSJB2+NXfBQ5+G5vSGJLUVyeuWJhhzfNddJ2vXJ9eEbBh/Esx6d0d4GzcDsrIz931IvaA7ga4EqOj0uhJYsp/rLg8hnA28DPxVjLFi7wtCCDcANwCUl5d3oyRJkiT1e4/f2hHm2jTXw4Of6HhdWA6lC2HJDUmAmzQP8ob1bp1SH9CdQLe/XnXc6/VDwM9ijI0hhI8B/wmcu88Xxfgj4EcAixYt2vsekiRJGgya6+HNJ5OO3IG8/84kwA0f33t1SX1YdwJdJVDW6XUpUN35ghjjtk4v/xX4djfeT5IkSQPNttfg1cfgld/Am3+EloYDX1tYBjPe3nu1Sf1AdwLdU8D0EMJxJLtYXgVc3fmCEMKkGOOG9MtLgBe68X6SJEnq75rq4M0/wau/SULcjjeS46OPh4UfgmkXwO6N8Mjnuy67zM1PNkaR1MVRB7oYY0sI4ZPAoyRjC34SY3wuhHArsCLG+CDw6RDCJUALsB340DGoWZIkSf1FjLDt1SS8vfpYEuZaGyEnH447G077BEw7D0ZP7fp12XmHt8ulNMiFGPvWI2uLFi2KK1asyHQZkiRJOlpNe+CNP3Z04WrWJcfHTIfpF8C082HyGZA7NLN1Sn1UCGFljHHRXeQ0bQAAIABJREFU4VzbrcHikiRJEjHC1pc7unDrnkwGeecWwHFvgTM+nYS4UVMyXak04BjoJEmSdOQad8Mbf0h34R7rmAc3dgYsviHdhTsdcoZktk5pgDPQSZIk6dBihC0vdnTh1v856cLlDU+6cGf9VRLiipwpLPUmA50kSZL2r3EXvP5E0oV79fGO+XDjZsKSG5MdKctPg5y8zNYpDWIGOkmSJCVihM3Pd+3CpVogbwRMfQuc/Xk4/jwoKjv0vST1CgOdJEnSYNawE17/fUcXbmdVcnz8rPRIgQugbIldOKmPMtBJkiQNJjHCpmc7unAVy5Iu3JCRMPUcOOcLybNwI4szXamkw2CgkyRJGujqa7p24XZtSI5PmAOnfyrdhVsM2bkZLVPSkTPQSZIkDTQxwsY1nbpwyyG2wpBCOP6tyXDv48+DkZMyXamkbjLQSZIkDQT1O+C13yUB7tXHYPem5PjEuXDmZ5MuXOkpkO2vf9JA4v+jJUmS+qNUCjY+kwz1fvU3UPkUxBQMLYLjz+3owo2YkOlKJfUgA50kSVJ/UbcdXvttRxduz5bk+KT5cNbnki5cyUK7cNIg4v/bJUmS+qpUCjas6ujCVa1MunD5o5LuW1sXbvi4TFcqKUMMdJIkSX3Jnm3w2uPpLtzjULcVCFC8AM6+Od2FOxmysjNdqaQ+wEAnSZKUSalWqF6V3pHyN1D1NBChYEynLty5MGxspiuV1AcZ6CRJknrb7i1JF+6V3yTPxNVvB0Ly/Ns5X0i6cMXz7cJJOiQDnSRJUk9LtSbPv7V14apXk3ThxsL0t3V04QpGZ7pSSf2MgU6SJKkn7N6cPAfX1oVrqIGQBSWL4K1fgmnnJ7tTZmVlulJJ/ZiBTpIk6VhobYGqFR1duA3PJMeHjYcZF8P082HqW+3CSTqmDHSSJElHa9fGji7c67+DhloI2VC2GM792+RZuIlz7cJJ6jEGOkmSpMPV2gKVyzu6cBvXJseHT4QT35Xuwp2TzImTpF5goJMkSTqYndWdunBPQGO6C1d+Kpx3S7oLNwdCyHSlkgYhA50kSVJnrc1QsSzdhXsMNj2bHB8xCU66JNmRcuo5MLQwk1VKEmCgkyRJgtqqZAllWxeuaRdk5UD5aXD+V5Iu3IRZduEk9TkGOkmSNPi0NEHF0o4u3Obnk+MjS2D2e5Iu3HFvgaEjM1unJB2CgU6SJA0ONRXpLtxj8MYT0LQbsnJh8mlwwa1JF278TLtwkvoVA50kSRqYWhph/Z87unBbXkyOF5bBnPemu3Bnw5ARma1TkrrBQCdJkgaOHes6deH+AM17IDsPJp8OC65NunDjZtiFkzRgGOgkSVL/1dwA656EVx9PgtzWl5PjReUw76qkCzflLBgyPLN1SlIPMdBJkqT+ZfsbHXPh3vwjNNdB9hCYcgYsvA6mnQ9jp9uFkzQoGOgkSVLf1lwPbz6ZdOBefQy2vZocHzUF5l+T7sKdCXnDMlqmJGWCgU6SJPU9217r1IX7E7TUQ87QJLid8tGkCzfmeLtwkgY9A50kDWRr7oLHb4XaSigshfNugblXZroqaV9NdUlwa+vCbX89OT56Kpz8F0kXbvIZkFeQ2TolqY8x0EnSQLXmLnjo08lyNYDaiuQ1GOqUeTGmu3C/Sbpw656ElgbIyYfjzoIlfwnTzku6cJJ0jD2wqorbHn2J6pp6iovyufnCGVy2oCTTZR0VA50kDTRNdVD9NDzy+Y4w16a5Hu7/GPzuG8kmEtl5kJOXfJ6Tl7zOzoOcIUf4ed6+99vvvfd6H5fLDS5Ne+CNP3aEuJp1yfEx05LNTKafn3ThcvMzW6ekAe2BVVV88b611De3AlBVU88X71sL0C9DnYFOkvqzGJPllBXLoGJ58nHTs5BqOcjXtELZkmTocmtTx8fmeqivgdZmaG2ElqbkePvnjQe/79HI3jtE5qZD36HCYm76miMJood77zzIyjq23+dgFSNsfaVTF+5/kp+j3IJkoPfpn0qehRt9XKYrlTRAtaYim3Y2ULG9jsod9VTsqONfnni9Pcy1qW9u5bZHXzLQSZJ6WEsTbFyTDnDLoOIp2FWdnMstgJKFcMZnksD28F/Bzqp971FYBu/50dG9fyrVEfJam9NhsPPnnQLifj9vC4udj7fdr/Pnne7d0gSNuw9+v9amo/8z3Z+snCMMjrmdrjlIp7Lz/do/P4IgmpV9bL/P7trfM5ozLk4Gerc9C1ezPrl27AlwyvVJF678dMgdmtnaJQ0IMUa27G6kYns9lTvSoa1TeKuuqae5NbZfH0Lyd037U11Tv/8TfZyBTpL6st2bOzpvFcuhelUSYCAZnDz59CS8lS2GCbMhu9O/1s//Stdn6CBZynbeLUdfT1YWZA3te7+Mx3iIgNjp8306jwcKn4f6vAmaaw5xv8Zj+32GrIMEx8MNi507lZ2DaN6R3fulR+DXX0p2n4TkGc37bwRC0gXOHQZT3wJnfDbpwo2afGz/LCQNCjFGauqa2wNa57DW9nljS6rL14wdnkfJqALmlBRy8ZxJlI7Kp2xUAWWjCyguGsq5f/cEVfsJb8VF/XO5t4FOkvqKVCtsfr7T8snlsOON5Fx2HkyaD4s/moS30sUwctLB79e28clg2OUyhCRk5AyBIZkuppMYk2WqhxsQ27uXzfv5fD9LYA/UJW3aDXXb9tMZ7XSPmDp0/Uf8/aYgbwRcdTuUn5b885CkQ9jd2ELF9r3DWkfHbXdj1+X+hfm5lI7KZ/r4Ebx1xnjKRhdQNjqf0lEFlI7KpyDv4BHn5gtndHmGDiA/N5ubL5zRI99fTzPQSVKm1NdA5YqO5ZNVK5NfxAGGjYfyJbDow0kHbtK8o+uKzb1yYAa4/iKEdBcsN9OV7Ku15TAD4gGW1P7ypv3ft2k3TD2nN78TSX1cQ3MrlZ1CWsWO+vbXFTvqqKlr7nJ9QV52uqOWz6lTxyQdttFJWCsdVUBhfvf+ndr2nJy7XEqSDl+MsO3Vrs++bXkhOReykuWS867qWD5ZNNkdINWzsnPSS3SPcq7bn76XLLPcW2Fpt8qS1P80taSorqk/wLLIerbu7rr8PC8nqz2czS0tbA9rbcsiRxXkEnr4v4GXLSjptwFub90KdCGEi4DvA9nAj2OM3zrAdVcAdwOnxBhXdOc9JalfaNoDVU8n4a3yqWT5ZP325NzQoiS0zb48+ViyEIYMz2y90pE675Zj/4ympD6pNRXZmN4psnNYq0x33DbubCDVaaOR7KxAcdFQykYVcN6J49s7bG3LIscNH0JWln9peawcdaALIWQDPwQuACqBp0IID8YYn9/ruhHAp4Fl3SlUkvqsGJNORefNSzauTTaGABg7A068ON19WwJjprstvvq/wfSMpjTApVKRrbsbk5CW3iWyYns9lTXJx+qaelpSXXeKnDgyCWynTh1D6egCytIdt7LR+UwcOZScbP8711u606FbDLwaY3wdIIRwJ3Ap8Pxe130N+A7w+W68lyT1HS2NsCE9OqAyvXnJrg3JudxhULoQzvyrJLyVLoKC0ZmtV+opPqMp9QsxRnbUNe93h8iKHXVU7XenyCGUjc5nXlkR75w7qcuyyElFQxmS08fGqAxi3Ql0JUDnxfOVwJLOF4QQFgBlMcaHQwgHDHQhhBuAGwDKy8u7UZIk9YBdm9LBLf3sW5fRAZNhypkdz76Nn9V1dIAkSb1gZ0Mzldu7hrXOG5Hsaeo6SLuoINkpcsaEEZw/c0KnZ9jyKSkqID/PwNZfdOe3jv0tfG3vxYYQsoDvAR861I1ijD8CfgSwaNGiA4z6k6Re0NrSMTqg8qnk4443k3PZeVC8ID06IB3gRkzMaLmSpMGhvim9U+QBlkXW1nfdKXJYXnb6ubUCTjt+TPJ5ellk6eh8Rg7tg7vv6qh0J9BVAmWdXpcC1Z1ejwBmA79P71IzEXgwhHCJG6NI6jPqd3QaHbC86+iA4ROS0HbK9R2jA5yrJUnqAY0trVTXNOx3WWTljjq27m7qcv2Q9E6RZaMLmF9WRNmogvZn2MpGFVDUCztFqm/oTqB7CpgeQjgOqAKuAq5uOxljrAXGtr0OIfwe+LxhTlLGxAhbX+n67NuWF5NzIRsmzoZ57+80OqDc0QGSpGOipTXFhtqGTjtEdt3af9OuBmKndWo5WYGSUfmUjsrn/JkTusxhKxudz9hh7hSpxFEHuhhjSwjhk8CjJGMLfhJjfC6EcCuwIsb44LEqUpKOStOepOPW9uxb5fKkIwfp0QFLYM4Vycfikx0dIEk6aqlUZMvuxmQpZHpL/7awVllTR3VNA6177RQ5aeRQSkcXcMa0sR1b+4/Kp3R0ARNHDiXbwKbDEGLsW4+sLVq0KK5YYRNP0hGKEWrWJ123tg1MNj7bMTpg3IlJ1610cXp0wDRHB0iSDluMke17mqhIP7/WeVlk1Y56Kmvqadprp8hxI4Z02c6/87LISYX55OX43yHtXwhhZYxx0eFc61ZskvqnlkbY8EzHs28Vy2H3xuRc7rBkXMBZN3WMDsgfldl6JUl9Xm198147RHYaor2jnrq9doocVZBL6agCTpw0ggtOSnaKTGayJcsjh+a6U6R6noFOUv+wa1PXZ9+qV0Fr+gHxUVNg6lug9JQkwI0/ydEBUi94YFUVtz36EtU19RQX5XPzhTO4bEFJpsuSDqiuqaXTDpFdn2Gr3FHHzoaWLtcPH5JD6ah8Jo8ZxpnTxnUsixydT0lRPiPcKVJ9gL/xSOp7Wltg83MdnbeKZVCzLjmXPSQZHbDkxnT3bTGMmJDZeqVB6IFVVXzxvrXUNycdi6qaer5w3xqaW1NcMr+Y7BDICsFNG3TUjuYvDBqaW6muqd9nWWTljnoqt9exbU/XnSKH5mYlSyBH5bNw8qh9lkUW5rtTpPo+n6GTlHl125PRAW3PvlWuhOY9ybnhE6F8Scezb5PmOjpAypDm1hSvbNrNs1W1fPWh5/YZVHwgWQGyswIhBLJDSH+eHMtqC36dX2dBVvrafa7LIn08pI/Tfu7Q902/bv96DnA8fd/012XvdU1WVtd7J98XnY4n9w7tX9u1xsOt+UDf4961hQP82bXXfIB792V7/4UBQH5uNt+4bBanHDdmv1v7V+yoY9POxi73yc0OlBR1PMNWml4KWZZeFjl2eF6f/7PQ4OQzdJL6rlQKtr3S9dm3rS8l50I2TJwDC67pGB1QWOboACkDOoe3ten/vbBhJ417bfqwPzdfOINUKtIaI6mY7P6XisnrGKE1/To5Tvp4TB/vfD3t17Wfi+lzqa73akmlaGolfTz93qn9XB/b3pv24we7byr9PXTenXCgOPJA3HtB++E1G7qEOYD65lZuuntNl2NZASYVJlv7nzU9vSRyVEH7Fv8T3ClSg4CBTlLPatydjA5oe/atYjk01CTn8kclwW3ulcnHkpMhb1hm65UGoebWFC9v2tUpvO3khQ0723fsGz4kh5OKR3LtqZOZU1LInNJCPvBvy6iuadjnXiVF+XzirdN6+1voFfEAAXDv0No5LHYNkR3hcO+weKB7HyhcpjoF045ATKfjSSDe5757Be391dYeiDt/XykOcLxngvbem4909u3L56SXSRYwqWgoudnuFKnBzUAn6diJMXnWreKpdAduGWx6FmL6b/THzYSTLk06b22jA+y+Sb2qLbytrUzC27NVtbywcVeX8DareCR/cepk5pQWMrukkOPGDNvnWbi/vvDE/S6Ju/nCGb36/fSmEAI52f47qzec8a3fUlVTv8/xkqJ83ndKeQYqkvouA52ko9fckIwOaHv2rWI57N6UnMsbnh4d8Pn05iULHR0g9bKmlq6dtwOFtw+eNpnZJYXMKSlkyn7C2/60bU7hLpfqCTdfOGPQ/YWBdLQMdJIO366NXZ9927C60+iA42DqW6Gs0+iALOfvSL2lLbyt7RTeXtywi6bWJLyNGJLDrJKjC28HctmCEgOceoR/YSAdPne5lLR/rS3JcsnKTssna9Yn57KHJM+7tc19K1sMw8dntl5pEDlkeBuaw+ziwvYlk3NKCpk8usARApLUT7jLpaQjV7c9Hd7Syyernu4YHTBiUhLclnws+ThxLuTkZbZeaZBoaknx0sau4e2ljfuGt+vOmNIe3soNb5I0aBjopMEolYKtL3d99m3ry8m5kJ3MeltwbcfmJYWlbl4i9YLGllZe3ri7a+dt406aW5PVNCOH5jC7pGt4mzymwDlakjSIGeikwaBxVzI6oG33ycrl0FCbnMsfnYS2eVclH4sXODpA6gWNLa3tnbe2TUte2rirS3ibU1rIh888LhkVkO68Gd4kSZ0Z6KSBJkbY8WbXZ982PZceHRBg/Ew46bL0s29LYMzxdt+kHtYW3tZUdoS3lzcdOLzNLSmibHS+4U2SdEgGOqm/a25Idpus6LR8cs/m5FzeiGR0wNk3J8snSxZBflFm65UGuIbmfTtvncNbYX4uc0oK+ciZU9s7b4Y3SdLRMtBJ/c3ODeln39IBrno1pJqTc6OnwrTzOnafHD/T0QFSD2pobuXFtvBW2RHeWlJdw9v1Z3WEt9JRhjdJ0rFjoJMybc1d8PitUFuZbD5y3i0w98rkXNvogM7dt9r06ICcoVB8Mpz28fTg7sUwfFzmvg9pgDtUeCsqSMLbR2cY3iRJvcdAJ2XSmrvgoU9Dc33yurYCfvEJeO7+jo1MmuuScyOKoXwJnPqX6dEBcxwdIPWQhuZWXtiws33J5NqqnbzSKbyNKshldkkhN6TD22zDmyQpQwx0UiY9fmtHmGvT2gQvPZJ0307+i66jAyQdc23hbW1VLWvTnbdXNu+mda/w9ta2zltpISVFhjdJUt9goJMyqbbyACcC3PC7Xi1FGgwamlt5vq3ztp/wNnpYHrNLCjlv5vj2zpvhTZLUlxnopExItcIfvwvE/Z+3Gyd1W31Tp/CW3nFyf+Ht/JkTkiHdpYUUFw41vEmS+hUDndTbdm2E+z4Kb/wh2chk41po6bTsMjc/2RhF0mE7VHgbY3iTJA1QBjqpN73yGNx/Y7LRyaU/hPnXwNq7D7zLpaR9JOGtbcnkznR420U6uzF2eBLeLjgpHd5KCplkeJMkDVAGOqk3tDTBb78G//MDGD8L3vvvMG5Gcm7ulQY46QDawtuayo7O26ubd+8T3t42Kwlvc0sLmTjS8CZJGjwMdFJP2/4G3PuRZATBoo/Ahd9IllVK6qKuqYXnq9O7Te43vA1hTslILpo1sX3ZpOFNkjTYGeiknvTc/fDgp4EA7/1PmHVZpiuS+oQ9jS08v2Enaytr2597e21LR3gbN2IIc0oKuWj2pPYh3RNGDjG8SZK0FwOd1BOa6+HXX4CV/wGlp8Dl/wajJme6Kikj9hfeXt2ym7hXeHv7nCS8zS0tZMLIoZktWpKkfsJAJx1rm1+Ee66Dzc/DGZ+Fc/8WsnMzXZXUK/Y0tvBcetlk585bW3gbnw5vF6fD2xzDmyRJ3WKgk46VGGHVf8Ejfw1DhsO198G08zJdldRjOoe3tZU1rK2q5fWte/YJb++c27FscrzhTZKkY8pAJx0LDTvh4c/Cs/fC1HPg3T+CERMyXZV0zOxubOG5TpuV7B3eJoxMwtu75hUb3iRJ6kUGOqm7qp5OlljWVMC5X4Yzb4KsrExXJR21XQ3NPFfdMaR7bVUtb3QKbxNHDmV2SSGXzCthTulIZpcUMn6E4U2SpEww0ElHK5WCpf8XHvsKDJ8A1z0C5admuiqpiwdWVXHboy9RXVNPcVE+N184g8sWlLSfP9zwdqnhTZKkPslAJx2NPVvhgb+EV/4bTnwnXPIPUDA601VJXTywqoov3reW+uZWAKpq6vnre9fwuxc3E4Fn08sm20wqTMLbZfNLmFNSyOySQsaNGJKh6iVJ0uEw0ElH6o0/wn0fhbptcPHfwSnXg7Ox1Mc0NLfy9V++0B7m2jS1pPjFM9Xt4e3dC0qYXVrI7GLDmyRJ/ZGBTjpcqVZ44jvwh+/A6Klw9V0waW6mq5JIpSKvb93D6ooanqmoYXVFDS9s2ElL25TuvQTgz190B1ZJkgYCA510OGqrkq7cuidh3tVw8W3JaAIpAzbvamD1+hqeqUzC25qKWnY1tgAwfEgOc0sL+ejZU/n5UxVs39O0z9cXF+X3dsmSJKmHGOikQ3np18nzci2N8O5/gXlXZboiDSJ7GltYW1Xb3nl7pqKG6toGAHKyAidOGsEl84uZX1bE/LIipo4bTnZWsgR4xoQRXZ6hA8jPzebmC2dk5HuRJEnHnoFOOpCWxmQHy6X/FybOgSv+A8ZOy3RVGsBaWlO8vGl30nlLd+Be3rSLtpWT5aMLWDhlNB8uLWRBeRGzigsZmpt9wPu17WZ5sF0uJUlS/2agk/Zn22twz4dhw2pYfCNccCvkulW7jp0YI9W1nZZOrq9hbVVtezetqCCXeaVFvG3WRBaUFTG3tJAxw49805LLFpQY4CRJGsAMdNLe1twND38WsnLgqp/Cie/IdEUaAGrrm1lT2bFpyeqKWrbubgQgLyeLWcUjed8pZe1LJyePKSC4e6okSToEA53UpmkP/OqvYdXtUHYqXP5jKCrLdFXqh5paUrywYWf7piWrK2p4fUvHvLfjxw3j7BPGtoe3EyeOJC8nK4MVS5Kk/qpbgS6EcBHwfSAb+HGM8Vt7nf8Y8AmgFdgN3BBjfL477yn1iE3Pwd3XwdaX4eyb4S1fgGz/vkOHFmNk3ba69uC2uqKG56t30tSaAmDs8CHMLyviPQtKmF82ijmlhRTm52a4akmSNFAc9W+sIYRs4IfABUAl8FQI4cG9AttPY4z/nL7+EuC7wEXdqFc6tmKEFT+BR78EQwvhLx6Aqedkuir1Ydt2N6Y7b7Xtu07W1jcDyQ6Sc0oL+dAZU5hfVsS8siKKC4e6dFKSJPWY7rQgFgOvxhhfBwgh3AlcCrQHuhjjzk7XDwP2P+VWyoT6Gnjo0/D8L+D485KRBMPHZboq9SENza08W5UObpW1rK7YQcX2egCyApwwYQRvnz2Reemlk9PHDycn26WTkiSp93Qn0JUAFZ1eVwJL9r4ohPAJ4CYgDzh3fzcKIdwA3ABQXl7ejZKkw1TxVLKL5a7qZAfL0z4FWf4iPpi1piKvbdnd3nVbXVHDixt30ZqeGVBcOJT55UVcu2Qy88uKmF1SyLAhLsuVJEmZ1Z3fRva3hmifDlyM8YfAD0MIVwN/C3xwP9f8CPgRwKJFi+ziqeekUvA/P4Dffg1GFsN1v4ayUzJdlTJg084GVu01MmB3YwsAI4bkMK+siI+9ZSrzy0Yxr7SQ8SMdWyFJkvqe7gS6SqDzFoClQPVBrr8T+KduvJ/UPbu3wP03wmuPw0mXwrt+APlFma5KvWB3Y0t6ZECybPKZilo27mwAICcrcFLxSN69oKR96eTUscPIyvK5N0mS1Pd1J9A9BUwPIRwHVAFXAVd3viCEMD3G+Er65TuAV5Ay4fXfw303QEMtvPN7sPA6cKOKAamlNcWLG3fxTKeZb69s3k1M9/4njylgydTRzCstYn55ESdNGsnQ3OzMFi1JknSUjjrQxRhbQgifBB4lGVvwkxjjcyGEW4EVMcYHgU+GEM4HmoEd7Ge5pdSjWlvg99+EP/49jD0BPnA/TJiV6ap0jMQYqdxR3+W5t2era2loTkYGjCrIZX5ZERfPmZTsOllaxKhheRmuWpIk6dgJMfatR9YWLVoUV6xYkekyNBDUVMC910PFUljwAXj7tyFvWKarUjfU1jWzulPn7ZmKGrbtaQJgSE4Ws0sK2ztv80uLKBud78gASZLU74QQVsYYFx3OtW7RpoHphYfhF5+AVCtc/m8w54pMV6Qj1NjSyvPVO3mmfWRADW9s3QMkq2WnjRvOW08cz7yyIhaUFTFj4ghyHRkgSZIGGQOdBpbmBvjNl2H5j2DSfLjiJzDm+ExXpUNIpSJvbNuThLd09+35DTtpbk1WEIwfMYT5ZUVcsbCUBWVFzC4tZOTQ3AxXLUmSlHkGOg0cW1+Be66DjWvh1E/A+V+BHJ+X6ou27GpMd946lk7ubEhGBhTkZTO3tJAPn3kcC8qKmFdWxMSRQ106KUmStB8GOg0Mq38Gv/wc5AyB9/8cZlyU6YqUVt/Uytqq2vbO2+qKGqpq6gHIzgrMmDCCd8wtZn5ZIfPLRjFt/HCyHRkgSZJ0WAx06t8ad8Mjn4dnfgaTz4TL/zUZGK6MaE1FXtm8Kx3ekufeXt60i9ZUsnSypCif+eVFfOj0KcwvL2JW8UgK8vzXkCRJ0tHyNyn1XxvWJEsst78O53wRzr4Zspwn1ltijGzc2cDq9TWsrqxh9foa1lbVUtfUCsDIoTnMKyvi/JnHM7+siLmlRYwbMSTDVUuSJA0sBjr1PzHC8n+F//4bKBgDH3wIppyZ6aoGvF0NzaxJ7zbZtnxy865GAPKys5hZPJL3LixlXlkR88uKmDJmGFkunZQkSepRBjr1L3Xb4cFPwYsPw/QL4bJ/gmFjMl3VgNPcmuKljbtY1Sm8vbZlN21jK6eOHcYZ08Yyr7SQ+eWjmDlpBENy7I5KkiT1NgOd+o/1S+Gej8DuTXDh/4ZTP54MJFO3xBip2F7PqoodPFNRy+qKHTxXvZPGlhQAY4blMb+siEvmFaeXThZSVODuoZIkSX2BgU59X6oV/vRd+N03oagcPvLfUHJypqvqt3bsaWJ1ZU37zLdnKmvZvqcJgKG5WcwpKeQDp05mfnkR80qLKB2V78gASZKkPspAp75t10a47wZ44wmYfTm88//A0JGZrqrfaGhu5bnqnV1mvq3bVgckzc0Txo/g/Jnj2597O2HCCHKzszJctSRJkg6XgU5916uPwf0fS0YTXPKPsOBal1geRCoVeX3rni6blrywYSct6ZEBE0cOZX5ZEVedUs78siLmlBYyfIj/CpAkSerMqPDqAAAgAElEQVTP/G1OfU9rM/z2a/Dk92H8SfDBh2H8iZmuqs/ZvCsZGdDWeVtTUcuuxhYAhg/JYW5pIR89eyrzSpPu28TCoRmuWJIkSceagU59y443k41PqlbAwuvgom9Cbn6mq+pRD6yq4rZHX6K6pp7ionxuvnAGly0o6XLNnsYW1lbVdiydXF9DdW0DANlZgRMnjuCS+cXMKytiQVkRU8cNJ9uRAZIkSQOegU59x3MPwIOfBiK89z9g1rszXVGPe2BVFV+8by31zckw7qqaer5w3xqqauoZPSyvfenky5t2kV45SdnofBZOGc2HSwtZUF7ErOJChuY6MkCSJGkwMtAp85rr4dEvwYqfQMlCuOInMGpKpqvqFbc9+lJ7mGvT0JzitkdfAqCoIJd5pUW8bdZEFqRHBowZPiQTpUqSJKkPMtAps7a8BHdfB5ufgzM+A+d+GbJzM11Vr6jYXkdVTf0Bz//+8+cweUyBIwMkSZJ0QAY6ZUaMsOp2+NVfQ24BXHMvTD8/01X1uNZU5PcvbeaOZev53UubD3hdSVE+U8YO68XKJEmS1B8Z6NT7GnbCL2+CtXfDcWfDe/4VRkzMdFU9avOuBu5eUclPl62nqqaecSOG8Km3TmPUsDy+8+uuyy7zc7O5+cIZGaxWkiRJ/YWBTr2r6mm458NQsw7O/Vs48ybIGpgbesQYWfr6dm5fto5Hn91ISypyxrQx/M07ZnLBSRPaB3iPKsg75C6XkiRJ0v4Y6NQ7YoSl/wS/uQWGj4cPPQKTT8t0VT2itq6Ze5+u5I5l63htyx4K83P54OlTuHpJOcePG77P9ZctKDHASZIk6agY6NTz9myDX3wcXv41zHgHXPqPUDA601Udc89U1HD70nU8tKaahuYU88uK+Lv3zuOdcyc5VkCSJEk9wkCnnvXmn+De66FuG7z9O7D4BhhAuzbWNbXw4Opq7li2nrVVtRTkZfPuBaVcs6Sc2SWFmS5PkiRJA5yBTj0j1Qp/uA2e+DaMOg6u/zlMmpfpqo6ZVzbt4o5l67n36Up2NbRwwoTh3HrpLC5bUMLIoYNj7IIkSZIyz0CnY29nNdz7UVj3J5h7Fbzj72DIiExX1W2NLa08+twmbl+6juVvbCcvO4uL50zkmlMns2jyKOfFSZIkqdcZ6HRsvfwoPPCX0NwAl/0zzH9/pivqtortdfx0+XrueqqCbXuaKB9dwBfefiLvXVjKmOFDMl2eJEmSBjEDnY6NliZ4/Kvw53+ECXPgvf8OY6dnuqqj1pqK/O7Fzdy+bB1PvLyFAJw3cwLXnjqZs6aNJSvLbpwkSZIyz0Cn7tv+ejJbrnoVnPJReNvXIXdopqs6Kpt3NfDz5RX8bPl6qmsbGD9iCJ86dzrvX1zGpML8TJcnSZIkdWGgU/esvQce+ixkZcH7boeZ78p0RUcsxsifX9vG7cvW8d/PbaIlFTlz2lhueddJnDezYwC4JEmS1NcY6HR0mvbAr/4/WPVfULYELv8xFJVnuqojUlvXzD3pAeCvpweAfyg9AHzqfgaAS5IkSX2NgU5HbtPzcPeHYOvLcNbn4JwvQXb/+FGKMfJMZW0yAPyZahpbUiwoL+Lv3zuPdzgAXJIkSf1M//gtXH1DjLDyP+DXX4AhI+ED98Pxb810VYelrqmFX6yu5val63iueicFedlcvjAZAD6r2AHgkiRJ6p8MdDo89TXw0Gfg+Qfg+HPh3f8Cw8dnuqpDemnjLu5Yto77n65iV2MLJ04cwdcum81l84sZ4QBwSZIk9XMGOh1a5Qq45zqorYLzvwKnfybZBKWPamxp5dfPbuT2pet46s0d5GVn8Y65k7j21HJOLncAuCRJkgYOA50OLJWCP/8DPH4rjCiGD/8ayhZnuqoDWr+tjjuWr+PuFZVs39PE5DEFfOniE7liYRmjh+VlujxJkiTpmDPQaf92b4EHPgavPgYzL4FL/gHyizJd1T5aWlP89sXN3LFsPX94ZQtZIXD+zPFcs2QyZzoAXJIkSQOcgU77ev0JuO+jyXNz7/guLPow9LFlipt3NnDnU8kA8A21DUwYOYRPnzudqxwALkmSpEHEQKcOrS3wxLfgD38HY6fDtffBxNmZrqpdjJH/eW0bty9dx2+eTwaAnzV9LP/rXbM4b+Z4B4BLkiRp0DHQKVFbCfdeD+v/DPOvhYu/A3nDMl0VADV1TdyzspKfLlvP61v3UFSQy4fPPI73Ly7nuLF9o0ZJkiQpEwx0ghd/CQ98HFIt8J5/hblXZroiYoysqqjhjqXreXhNMgB84eRRfPfcaVw8xwHgkiRJEhjoBreWRvjvL8Pyf4FJ8+CKf4cxx2e0pD2NLTywuoo7lq7n+Q07GZaXzRULS7lmyWROKh6Z0dokSZKkvqZbgS6EcBHwfSAb+HGM8Vt7nb8JuB5oAbYAH44xruvOe+oY2fpqMltu4xo49ePJfLmcIRkr58WNO7lj6XruX1XF7vQA8K9fNpvLFpQwfIh/7yBJkiTtz1H/phxCyAZ+CFwAVAJPhRAejDE+3+myVcCiGGNdCOEvge8A7+tOwToGnrkTHr4JcvLg/XfCjLdnpIyG5o4B4CvW7SAvJ4t3zpnENadO5uTyIgeAS5IkSYfQndbHYuDVGOPrACGEO4FLgfZAF2P8XafrlwLXduP91F2Nu+GRm+GZn0L56XD5j6GwpNfLWLdtDz9dtp67VyYDwKeMKeBvLp7JFQtLGeUAcEmSJOmwdSfQlQAVnV5XAksOcv1HgF/t70QI4QbgBoDy8vJulKQD2rgW7r4Otr0Kb/kCnH0zZPfeUsaW1hSPtw0Af3kL2VmBC2ZO4JpTyznjeAeAS5IkSUejO7/R7+838LjfC0O4FlgEvGV/52OMPwJ+BLBo0aL93kNHKUZ46sfw6N9A/ij44ENw3Fm99vYbaxu486n13Lm8go07G5g4ciifPX86V51SzsTCob1WhyRJkjQQdSfQVQJlnV6XAtV7XxRCOB/4G+AtMcbGbryfjlT9DvjFJ+HFh2HaBfDuf4ZhY3v8bVOpyJOvbeWOpev5zQubaE0PAP/qpbM478Tx5DgAXJIkSTomuhPongKmhxCOA6qAq4CrO18QQlgA/AtwUYxxczfeS0dq/TK49yOwayO87RvJTpZZPRukduxJBoDfsWwdb26rY1RBLtefeRxXLyln8hgHgEuSJEnH2lEHuhhjSwjhk8CjJGMLfhJjfC6EcCuwIsb4IHAbMBy4O71j4foY4yXHoG4dSCoFT34PfvsNKCqDjzwKJQt77O1ijDy9voY7lq7j4bUbaGpJsWjyKD57/glcNHuiA8AlSZKkHtStXTFijI8Aj+x17JZOn5/fnfvrCO3aBPffAK//Hma9B971f2BoYY+81e7GFh5YVcUdy9bzQnoA+JWLkgHgMyc5AFySJEnqDU5sHihefRzuvzEZTfCuH8DJfwE9MMfthQ07uX3pOh5YVcWeplZmThrJN949m0vnOwBckiRJ6m3+Bt7ftTbD774Bf/oejJuZ7GI5fuYxfYuG5lZ+9ewGbl+6npVtA8DnTuLaUyezoMwB4JIkSVKmGOj6sx3rko1PKp+ChR+CC78JeQXH7PZvbt3DT5ev5+4VFeyoa+a4scP423ckA8CLChwALkmSJGWaga6/ev4X8OCnkjlzV/wEZl9+TG7b0prisRc2c8eydfzxla1kZwXedtIErj11MqdNHeMAcEmSJKkPMdD1N831yZDwFf8GxScnYW70cd2+7cbaBn62fD13PrWeTTsbmVQ4lJsuOIH3nVLGhJEOAJckSZL6IgNdf7LlJbjnw7DpWTj9U3DuLZBz9EsfU6nIn17dyu1L1/H4i5tJxcjZ08fxtUvLOdcB4JIkSVKfZ6DrD2KE1XfAIzdDbj5ccw9Mv+Cob7d9TxN3r6jgp8vXs25bHaOH5XH9WcdxzeLJlI85ds/gSZIkSepZBrq+rnEXPHwTrL0LppwF7/lXGDnpiG8TY2Tluh3csWw9v0wPAD9lyihuuiAZAD4kxwHgkiRJUn9joOvLqlfDPdfBjjfhrX8DZ30Oso4seO1qaOaB1dXcsXQdL27cxfAhOVx1ShnXLJnMjIkjeqZuSZIkSb3CQNcXxQjL/hn++8swfDx86Jcw+fQjusXz1Tu5fdk6fpEeAD6reCTffM8cLplXzDAHgEuSJEkDgr/Z9zV12+GBj8PLv4IZF8OlP4SC0Yf1pQ3NrfxyzQZuX7aOVetrGJKTxbvmFXPNknLmOwBckiRJGnAMdH3Jm0/CvddD3Va46Nuw5EY4jBD2xtY93LF0Hfc8XUlNXTNTHQAuSZIkDQoGur4g1Qp/+Dt44lswagp85DdQPP+gX9LcmuKx5zdxx7L1/OnVreRkBd42awLXLpnMacePsRsnSZIkDQIGukzbuQHu+yi8+UeYcyW887sw5MCblWyorednyyu4c/l6Nu9qpLhwKJ9LDwAf7wBwSZIkaVAx0GXSK7+B+2+E5nq49P/C/Kv3u8QylYr8sW0A+AubiMBbThjHN5ZM5q0zxjkAXJIkSRqkDHSZ0NIEj38V/vyPMGE2XPHvMO6EfS7btruRu1dW8tNl61m/vY4xw/K44ezjuXpxuQPAJUmSJBnoet32N+CeD0P103DK9fC2r0NufvvpGCMr1u3g9qXr+NXajTS1plg8ZTSfe5sDwCVJkiR1ZaDrTc/eCw99NllWeeV/wUmXtJ/a1dDM/auquGPpel7atIsRQ3J4/+Iyrjl1MidMcAC4JEmSpH0Z6HpDUx38+gvw9H9C6WK4/McwajIAz1bVcsey9fxidRV1Ta3MLhnJt94zh0vmF1OQ5z8eSZIkSQdmYuhpm1+Au6+DLS/CmTfBW79EQyqLh1dWcvvSdayuSAaAXzKvmGtPnczc0kJHDkiSJEk6LAa6nhJj0pH71RdgyHD4wH28PnIxd/zqFe5ZWUltfTNTxw3jlneexOUnl1JYkJvpiiVJkiT1Mwa6ntBQmzwr99x9pI47h9+e9DV+8ts6/ue1J8jJClw4ayLXnFrOaVMdAC5JkiTp6BnojrXKlXDPdcTaSv5U/gk+V3EOm1+ooKQon8+/7QSuPKWM8SMcAC5JkiSp+wx0x0oqRerP/wiPfZUdWaO5sfHLrHzlBM45oYhvnjqZc2aMJzvLbpwkSZKkY8dAdwxs21zF7js/yuTtT/Lr1lP4dt4nePvZM/ne4nLKRjsAXJIkSVLPMNAdpRgjT725g2W/fYAr13+Viezh3wo/wbhzP8GjsyeRl5OV6RIlSZIkDXAGukN4YFUVtz36EtU19RQX5fPJc4+nqSXys6Wv8/bt/49P5TzA9qFlbLzkLj4ya0mmy5UkSZI0iBjoDuKBVVV88b611De3AlBVU88X73uWiWzjx8P/mdk5z9Ey9/2MfeffMzZvWIarlSRJkjTYGOgO4rZHX+KC1if467y7KA5bqY5jeSS1mCtz/kBRiPDuH5Ez732ZLlOSJEnSIGWgO4hFO3/DN3N/TEFoAqA0bOWGrEeoSI2l6MZHYey0DFcoSZIkaTAz0B3EF/PupoCmfY7nZmGYkyRJkpRxbsV4EBPYeoDj23q5EkmSJEnal4HuIEJh6REdlyRJkqTeZKA7mPNugdz8rsdy85PjkiRJkpRhBrqDmXslvOsHUFgGhOTju36QHJckSZKkDHNTlEOZe6UBTpIkSVKfZIdOkiRJkvopA50kSZIk9VMGOkmSJEnqpwx0kiRJktRPGegkSZIkqZ8y0EmSJElSPxVijJmuoYsQwhZgXabr2I+xwNZMF6EBzZ8x9SR/vtST/PlST/LnSz2pr/58TY4xjjucC/tcoOurQggrYoyLMl2HBi5/xtST/PlST/LnSz3Jny/1pIHw8+WSS0mSJEnqpwx0kiRJktRPGegO348yXYAGPH/G1JP8+VJP8udLPcmfL/Wkfv/z5TN0kiRJktRP2aGTJEmSpH7KQCdJkiRJ/ZSB7jCEEC4KIbwUQng1hPCFTNejgSWE8JMQwuYQwrOZrkUDSwihLITwuxDCCyGE50IIn8l0TRpYQghDQwjLQwjPpH/GvprpmjTwhBCyQwirQggPZ7oWDSwhhDdDCGtDCKtDCCsyXc/R8hm6QwghZAMvAxcAlcBTwPtjjM9ntDANGCGEs4HdwP/P3p3Hx1WW/R//XNn3rWvSfaNNgULbUFZBWQSpWISyt4CiLLLogw8q6g8VNxQfRYVHxO2RLpQCBQoIiKgoKkpLoYUu0JaWLumattnXuX9/nJPJJJm00zTJySTf9+uVV2bm3HPONUBLvrnv+zoPO+eOCboe6TvMrBAodM69YWbZwHLgQv39JV3FzAzIdM5Vmlky8CrweefcawGXJn2Imd0OlAA5zrmPB12P9B1mtgkocc71xhuLx0wzdIc2A1jvnNvonKsHFgGzAq5J+hDn3N+AsqDrkL7HOVfqnHvDf1wBrAGGBVuV9CXOU+k/Tfa/9Jti6TJmNhyYCfw66FpEeisFukMbBmyJeL4V/UAkInHGzEYDU4F/B1uJ9DX+crg3gV3AS845/TcmXek+4EtAKOhCpE9ywB/NbLmZXR90MZ2lQHdoFuU1/fZRROKGmWUBTwBfcM6VB12P9C3OuSbn3PHAcGCGmWnpuHQJM/s4sMs5tzzoWqTPOtU5Nw34GHCzvw0m7ijQHdpWYETE8+HA9oBqERE5LP6+pieABc65JUHXI32Xc24/8FfgvIBLkb7jVOAT/j6nRcCZZjY/2JKkL3HObfe/7wKexNtqFXcU6A7tdWCCmY0xsxTgcmBpwDWJiByS37DiN8Aa59yPg65H+h4zG2Rmef7jdOBsYG2wVUlf4Zy70zk33Dk3Gu/nrz875+YEXJb0EWaW6TcMw8wygY8CcdlxXIHuEJxzjcAtwIt4DQUWO+feCbYq6UvM7BHgX8BEM9tqZtcFXZP0GacCc/F+q/2m/3V+0EVJn1II/MXMVuL9AvQl55xay4tIPBgCvGpmbwH/AZ5zzr0QcE2dotsWiIiIiIiIxCnN0ImIiIiIiMQpBToREREREZE4pUAnIiIiIiISpxToRERERERE4pQCnYiIiIiISJxSoBMRkT7LzJoibtnwppl9pQvPPdrM4vKeRSIi0nckBV2AiIhIN6pxzh0fdBEiIiLdRTN0IiLS75jZJjP7gZn9x/8a778+ysxeNrOV/veR/utDzOxJM3vL/zrFP1Wimf3KzN4xsz+aWXpgH0pERPolBToREenL0tssubws4li5c24GcD9wn//a/cDDzrkpwALgZ/7rPwNecc4dB0wD3vFfnwA84Jw7GtgPXNzNn0dERKQVc84FXYOIiEi3MLNK51xWlNc3AWc65zaaWTKwwzk3wMz2AIXOuQb/9VLn3EAz2w0Md87VRZxjNPCSc26C//zLQLJz7jvd/8lEREQ8mqETEZH+ynXwuKMx0dRFPG5Ce9NFRKSHKdCJiEh/dVnE93/5j/8JXO4/vgp41X/8MnATgJklmllOTxUpIiJyMPpNooiI9GXpZvZmxPMXnHPNty5INbN/4/1y8wr/tduA35rZHcBu4FP+658HHjKz6/Bm4m4CSru9ehERkUPQHjoREel3/D10Jc65PUHXIiIiciS05FJERERERCROaYZOREREREQkTmmGTkREeoSZjTYzZ2ZJ/vPnzeyaWMZ24lpfNbNfH0m9IiIi8UCBTkREYmJmL5rZ3VFen2VmOw43fDnnPuac+30X1PVhM9va5tzfc8595kjPLSIi0tsp0ImISKz+D5hrZtbm9bnAAudcY8+X1L90dsZSRET6LgU6ERGJ1VNAAfCh5hfMLB/4OPCw/3ymma0ws3Iz22Jm3+zoZGb2VzP7jP840cx+ZGZ7zGwjMLPN2E+Z2RozqzCzjWZ2g/96JvA8UGRmlf5XkZl908zmR7z/E2b2jpnt969bHHFsk5n9t5mtNLMDZvaomaV1UPM4M/uzme31a11gZnkRx0eY2RIz2+2PuT/i2GcjPsNqM5vmv+7MbHzEuP8zs+/4jz9sZlvN7MtmtgP4nZnlm9mz/jX2+Y+HR7y/wMx+Z2bb/eNP+a+/bWYXRIxL9j/D8R39OxIRkd5PgU5ERGLinKsBFgNXR7x8KbDWOfeW/7zKP56HF8puMrMLYzj9Z/GC4VSgBJjd5vgu/3gO3r3hfmJm05xzVcDHgO3OuSz/a3vkG83sKOAR4AvAIOAPwDNmltLmc5wHjAGmANd2UKcB3weKgGJgBPBN/zqJwLPAZmA0MAxY5B+7xB93tf8ZPgHsjeGfC8BQvCA9Crge7//dv/OfjwRqgPsjxs8DMoCjgcHAT/zXHwbmRIw7Hyh1zkXep09EROKMAp2IiByO3wOXmFm6//xq/zUAnHN/dc6tcs6FnHMr8YLUGTGc91LgPufcFudcGV5oCnPOPeec2+A8rwB/JGKm8BAuA55zzr3knGsAfgSkA6dEjPmZc267f+1ngKizVs659f556pxzu4EfR3y+GXhB7w7nXJVzrtY596p/7DPAD51zr/ufYb1zbnOM9YeAb/jXrHHO7XXOPeGcq3bOVQDfba7BzArxAu6Nzrl9zrkG/58XwHzgfDPL8Z/PxQt/IiISxxToREQkZn5A2Q3MMrOxwAnAwubjZnaimf3FXw54ALgRGBjDqYuALRHPW4UdM/uYmb1mZmVmth9vdimW8zafO3w+51zIv9awiDE7Ih5XA1nRTmRmg81skZltM7NyvJDUXMcIYHMHewlHABtirLet3c652ogaMszsl2a22a/hb0CeP0M4Aihzzu1rexJ/5vIfwMX+MtGPAQs6WZOIiPQSCnQiInK4HsabmZsL/NE5tzPi2EJgKTDCOZcLPIi3TPFQSvHCSLORzQ/MLBV4Am9mbYhzLg9v2WTzeQ91Q9XteMsTm89n/rW2xVBXW9/3rzfFOZeDt4SxuY4twMgOGpdsAcZ1cM5qvCWSzYa2Od72830RmAic6Ndwuv+6+dcpiNzX18bv/ZovAf7lnOvMPwMREelFFOhERORwPQycjbfvre1tB7LxZohqzWwGcGWM51wM3GZmw/1GK1+JOJYCpOLNDDaa2ceAj0Yc3wkMMLPcg5x7ppmdZWbJeIGoDvhnjLVFygYqgf1mNgy4I+LYf/CC6T1mlmlmaWZ2qn/s18B/m9l084w3s+aQ+SZwpd8Y5jwOvUQ1G2/f3H4zKwC+0XzAOVeK1yTmf/3mKclmdnrEe58CpgGfx29kIyIi8U2BTkREDotzbhNeGMrEm42L9DngbjOrAO7CC1Ox+BXwIvAW8AawJOJ6FcBt/rn24YXEpRHH1+Lt1dvod7EsalPvOrxZqZ8De4ALgAucc/Ux1hbpW3iB6ADwXJs6m/xzjwc+ALbi7d/DOfcY3l63hUAFLR1DwQtXFwD7gav8YwdzH94ewD3Aa8ALbY7PBRqAtXjNZL4QUWMN3mznmMjaRUQkfplzh1qpIiIiIn2Fmd0FHOWcm3PIwSIi0uvpBqUiIiL9hL9E8zq8WTwREekDtORSRESkHzCzz+I1TXneOfe3oOsREZGuoSWXIiIiIiIicUozdCIiIiIiInGq1+2hGzhwoBs9enTQZYiIiIiIiARi+fLle5xzg2IZ2+sC3ejRo1m2bFnQZYiIiIiIiATCzDbHOlZLLkVEREREROKUAp2IiIiIiEicUqATERERERGJUwp0IiIiIiIicUqBTkREREREJE4p0ImIiIiIiMQpBToREREREelfVi6GnxwD38zzvq9cHHRFndbr7kMnIiIiIiLSbVYuhmdug4Ya7/mBLd5zgCmXBldXJ2mGTkRERERE+raafbDtDVj1ODz33y1hrllDDbx8dzC1HSHN0ImIiIiISHxzDip3QdlG2Pe+973s/ZbnNfsOfY4DW7u/zm6gQCciIiIiIr1fqMkLXe0C2ybvcUNVy1hLgNwRUDAWjv6k9z1/jPd9wSVQHiW85Q7vsY/SlRToRERERESkd2isg/0ftJ9hK9sI+zZDqKFlbGIq5I+GgjEw5vSWwFYwxgtzSSnRr3H2N1rvoQNIToez7urWj9ZdFOhERERERKTn1FX6Ia1NYCvb5DUowbWMTcmGgtEw5GiY9PGWwFYwFrKLIKETLUGaG5+8fLc345c73AtzcdgQBRToRERERESkKznn7VlrF9j871W7Wo/PGOAFtJEnQcGVLYEtfwxkDgSzrq9xyqVxG+DaUqATEREREZHD4xxU7Oi4CUntgdbjc4Z5Ae2oc1sHtoIxkJYbzGfoIxToRERERESkvaZGbwlkq8D2fstyycaIPWiWCHkjvaA2vKR1E5L8Ud4eNekWCnQiIiIiIv1VQy3s3xy9Ccn+DyDU2DI2Ka0lpI07029IEtGEJDE5sI/RnynQiYiIiIj0ZbXlUZqQ+F/l22jVhCQ11wtohcd57f4jO0dmDe1cExLpVgp0IiIiIiLxzDmo3ttxE5LqPa3HZw72W/1/qHVgKxgL6fnd04REuk1Mgc7MzgN+CiQCv3bO3dPm+I3AzUATUAlc75xbbWajgTXAOn/oa865G7umdBERERGRfiIUgorSDpqQbIK68ojB5rXiLxgDk2a2Dmz5oyE1O6APId3hkIHOzBKBB4BzgK3A62a21Dm3OmLYQufcg/74TwA/Bs7zj21wzh3ftWWLiIiIiPQxTQ3evrXIJZHNAW7fJmisbRmbkOw1G8kfAyNPbt05Mn8UJKUG9jGkZ8UyQzcDWO+c2whgZouAWUA40DnnIn8lkEmrhbgiIiIiIgJAQ40XzqI2IdkCrqllbHKGF9AGjIcJ57TuHJk7HBISA/sY0nvEEuiGAVsinm8FTmw7yMxuBm4HUoAzIw6NMbMVQDnwdefc36O893rgeoCRI0fGXLyIiIiISK9Ts7/jJiQV21uPTcvzAtqw6XDsJW2akAzRfjY5pFgCXbT/itrNwDnnHgAeMLMrga8D1xxM0K4AACAASURBVAClwEjn3F4zmw48ZWZHt5nRwzn3EPAQQElJiWb3RERERKT3cg6qdkeZZfMf15S1Hp811Ato4z7ScjPtgjHe44yCYD6D9BmxBLqtwIiI58OB7R2MBVgE/ALAOVcH1PmPl5vZBuAoYFmnqhURERER6QmhJq+lf7vOkZu8x/WVLWMtwW9CMhYmz2rfhCQlM6hPIf1ALIHudWCCmY0BtgGXA1dGDjCzCc659/ynM4H3/NcHAWXOuSYzGwtMADZ2VfEiIiIiIp3WWO81IYnWOXL/ZmiqbxmbmOKFs/wxMPq01k1I8kZCUkpgH0P6t0MGOudco5ndAryId9uC3zrn3jGzu4FlzrmlwC1mdjbQAOzDW24JcDpwt5k14t3S4EbnXFn7q4iIiIiIdIP6Ki+ktWv1/z4c2Aou1DI2JcsLaoOL/Xb/EaEtp0hNSKRXMud615a1kpISt2yZVmSKiIiI9GsrF8PLd3uhK3c4nHUXTLk0+tjqsuit/ss2QuXO1mPTC/wlkWNbB7aCsZA5UE1IpFcws+XOuZJYxsZ0Y3ERERERkR6zcjE8c5vX4h/gwBZYeivsedcLX22XSNbub/3+7CIvoLVt9V8wBtJye/7ziHQjBToRERER6V6hJqir8BqJ1FVAXSXUV0Q8roS68pbHby5sCXPNGmvhb/d6jy3R27dWMAaOnd46sOWPhuT0Hv+IIkFRoBMRERGR9hrr2wetuoqIYOY/r6+IeNz8ennrMY01h74eeI1HUrOhobqDAQa3vQG5IyAxucs+qkg8U6ATERER6Quc82axogWqaGGs3QxZReuxkR0eDyY5w2smkprlf8/xGoikZHnhLDULUrIjHvtjwo/95ylZLZ0if3KMt8yyreZbA4hImAKdiIiISFCc87owRgtUsYSutq+7ptiumxIZrvzHeaP8cJXdPmiFX89uPSYlCxK74cfJs+6i8elbSWqqDb/UmJhG0ll3df21ROKcAp2IiIjI4Qg1RQlUkcsSY5wha35MDB3HLSF6oMoeGiV0tfnedoYsORMSErr9H9OReKrpVF5t+AxfYBFFtpftbgD3hS7ntKZTuTDo4kR6GQU6ERER6fuaGmLc/xVt9qvNHrIO93e1kZDcPlBlFHjNPFKzDx66wq/7Y5LT+0U7/er6RnaV1/Gd51azp/4UHueUVsf/+txqjhmWS0FmCnnpySQk9P1/JiKHokAnIiIinXM49wk7XM5BY90hmnIcJHSFlys27weri+26SentA1XWUBjQQdA62LLEpNSu+WcR55xzlNc2sruill3ldeyqqGOX/3hnRR27ymvZXeG9XlnXeNBz7ams5+wfvwJAgkF+Rgr5mSkUZKYwINN7PMB/Hvk1IDOV/MxkUpN0Y3DpexToRERE5PBFu0/YM7d5IWzCOTHs/4qhQ2Lo4D/chzXv5Ypccpg3ok3oirJcMdoMWXfsB+ujnHPsq25gV0UtO8u9YLaros4PZ63DW21DqN3705ITGJKTxuDsVIoLczj9qFQG56QyODuN7/9hDXur2jdlGZCZwl0XTKasqr7V196qet7bVcm+qnr2VdcT6mAVa1ZqEgVtgl9zEIwWCrNSk7B+MDMq8U1/a4mIiPQVoSYvUDXVed+bv5rqvBb0jbWtjzX5r0UdV9/m9VrvWPP7ty3zljFGaqiBpbccuk5LiBKusiBrcJvuhzEsS0zJ6vX7weJNU8ixt7L1TNquijp2+oFtV0Udu8tr2V1ZR0NT++SUnZrEoJxUBmenMnVkHoOzvZA2OCeVQRGPsw8SlpISjDuXrKKmoaXJS3pyIv/v45OZdfywQ9Z/oKYhIvDVUVbVQFlVHXsjQuDO8lrWlJazt6qe+sb2gRMgJTGB/MxkCjJT24W9aKEwPyOFRC0DlR6mQCciInIknIsIRvVtwlS0YBTl8cGORZ47HMg6CF2xzmgdSmKqt1wwMQWS0rxW8klp/nP/WNswF2nmjw++LDE5o1/sB+tt6htD7KlsH8yaHzfPtO2trIs6w5WfkRwOY+MGDfAeZ6d6s2x+gBucnUZ6ypEva7xwqhfa7n1xHdv311CUl84d504Mv34wiQkWXmoZC+cc1fVN4Zm+ff73yCDYHAK37qtmb1U9FbXR/6yZQV56cgdLP9uHwoLMFNKStQxUjow5F0NnpR5UUlLili1bFnQZIiJ9Q3fucQqSc154OeQsU9vwExm6ajsORgcNXW3OF+u9ug4lIckPUpHhyQ9TiakdB6vm8NX28cGOhc8deSzi3LGErQ7vEzYC/uvtrvlnIjGpbWjyZ9H8cFZe6+9N815r3p9WFmUJoxkMyExlSEQgaw5ng/zHQ3LSGJiVov1nEeobQ+yvrm814xcZCL3HzUGwgX3V9TR1sA40IyUxyp6/yOCXSoE/S1iQmUJOmpaB9gdmttw5VxLLWM3QiYj0VR3tcYLOh7pQKPryu0POMh3OjFOM53bRl0gdHjtIEGoOPWmQltf9wSohzn5YPuuu1v99gdeJUfcJ6zKVdY3ebFqbYNa8V615pi3abFFSgvnLG1MZnp/BtFH5DMluPZM2OMebMUpK1JLVw5WSlMDgnDQG56TFND4UcpTXNrQKfm33AZZV1bO3sp73dlayt6ou6r5D8P7ddrT0M+pXhv4d93WaoRMRiVfOeeGn+abE9VWtv5beCjVl7d+XkgXHXNzxjFPU0OXPYIUOsszucCQkt5l9OpzwE0uwivHcicla+nck+uoMcDdyztvftStiBm1nxOza7ojH1fXtbxKempQQbhwy2A9sg3PSwuGtuclIfkaKWvrHuZr6pohZvijhz//evET0QE3Hfz/npie3C3kFWR2HwowUzfkE7XBm6BToRER6QlND9NAVGcYaqqOMqYT66uihraGq87NUWUNiDD/NgamDYBU+dhjLBBNT1cRC+pxQyLG3qj5qMPPa83szbbsr66I24MhMSQwHs+ZQ5oW1yPCWRk66lttJdA1NIfZXN7Ra7rnvILOBZVX1NHawDDQtOSF8q4fmvX8dzQAOyEwhJ033BOxqWnIpItJZoZAXlOo7CFcN0cLVIUJXfdXh7bNKSIaUTL+DX2bLV05RxHP/WHJGm3HNjzNg4WVQUdr+/NrjJBKzxqYQeyrrI+6b1tL1cXdEYNtTWRf1h+Pc9ORwMJsxpsDfmxYR2vzvman6kUyOTHJiAoP8/74g+5Djm+8P2Drkte4I2rwfcOPuSsqq6qPOGoPXiCY/IzlK4EulICOZgiy/IUxGCgOyvO8pSfrFXlfR3x4iEp/CNx2OEq46G7qaZ8liZm3ClB+uMgq8e2B1GLqag1dG++CWnOnNaHWFc+7WHieRDtQ1NkUNZi1LIL3X91bVE20x04DMlHAYmzgku/VMmv94UHaqOhhKr2Vm5KYnk5uezJiBmTG9p7ahqYOln607gq7bUUFZVT37axqi/vkByE5Lat0EptUy0JZGMM0NYjJTEjU73QEFOhHpfk0NnZjpimEp4uEsN0xKbx26mgNU1uCI0NV2VqyD0JXit11PTu/d+6+a9zJpj5P0I9X1jVHum1brL4FsWQa5v7r9fqPEBGNgVgqDs9Moyk3j+BG5EV0fW8LawKxUktVkQvqhtOREivLSKcpLj2l8U8ixv/rgjWDKqurZtr+WVdsOUFZVH/XehuA1oomc5Yu2H7DlWCq56ckHvSfgUyu2deq2GL2R9tCJBK03NRUIhVoHraihqxP7v5rqYq8hIamDYHWYoSs5cjYsM/46CIpIWPPSsN0Ryx1blkB6XR+bO0BW1rXv+JjiL0Vr1eGx+XlOy/60gkzdFFokSM45Kusa280A7qvqOBRG+zMPkGCQlxE9+G0tq+bZVaWtwmN6ciLfv+jYXhPq1BRFJF60bSsP3qzPBT87eKhrXm7YLkQ1P+7g9UM13WioOozirc0SwoiZq86GrpSsrltuKCLd7kh/w+2cY191Q8syR39GbXdEYGsOb9FauKcnJ7aEtIhg1raZSF5GspZqifRRdY1N7KtqOGRH0OZQuK+6ng56wTAsL51/fOXMnv0AHVBTFJF48fLdrcMceM+f+QKs+8PBlyK66BuTo0pKix66MgZGCWUxNt3o7csNRaRbPbViG3cuWUVNg/d30bb9Ndy5ZBUAFxxXxN7K1jNprZdA1rG7vJbdlXVRl1dlpyWFw9nUkXltbnjdci+1rFR1fBTp71KTEhmam8jQ3NjuCdgUcoz/6h+Ilum276+J8mrvp0AnEqQDW6O/3lAFO95uCVBZQzsXulIyvFmwRP1RF5Gu45zjnufXhsNcs5qGJm5f/Ca3L34z6m/A8zOSGeK35h8/aGC7m1wP8RuJpKdoibSIdI/EBKMoL51tUcJbrHsDexv9lCcSpPQ8qNnX/vXcEXCrlh6LSPAamkJs2F3JmtJyVm8vZ01pBWtKy9lbFf1WHCEHt505nkE5bW58nZWqNuUi0ivcce7EVisMwFvCfce5EwOsqvMU6ESCsuZZL8xZQutujWorLyIBOVDdwOrSclaXlrPG/3pvZyX1Td7fUSlJCUwcks3ZxUN44Z1SDtS0b0YwLC+d2z8anz8UiUj/0LzXt690uVSgEwnC5n/C45+G4SfAtGvhlXt6R5dLEekXQiHH5rLqcGhrnn3bfqA2PGZgViqTi3I4bcJAJhfmMLkwhzEDM0ny2/WfPG5An/oNt4j0LxdOHRa3Aa4tBTqRnrZzNTxyOeSPgisXezehnjYn6KpEpI+qrm9k7Y6KiCWT5azbUUFVvRfEEhOMcYMyOWFMAcV+cCsuzGFQdupBz9vXfsMtIhKvFOhEetL+LTD/Yq+JyZwlXpgTEekCzjl2lNe22+v2/t4qmu9QlJ2WRHFhDpeUjAgHtwlDskhL7lwTkr70G24RkXilQCfSU6rLYP5F3m0HPv085I0IuiIRiVP1jSHW76pstddtdWk5+6sbwmNGFmQwuTCHWccPo7gwm8lFOQzLS1ebfxGRPkaBTqQn1FfDwstg32aY+yQMOTroikQkTpRV1bcKbau3l7Nhd2X4/m1pyQlMHJrDx44ZGl4yOXFoNtlpyQFXLiIiPUGBTqS7NTXC45+Cbcvgkt/D6FODrkhEeqGmkGPT3qpWTUrWlFawo7ylUcmQnFSKC3P4yKTB4SWTYwZmkpigWTcRkf5KgU6kOzkHz34e3n0BZv4YJn8i6IpEpBeorGtk3Y5yVpdWtGpU0twxMinBGD84i5PHDQgHt+LCbAZkHbxRiYiI9D8KdCLd6c/fgRXz4YwvwwnXBV2NiPQw5xzbD9SGQ1vzssnNe6vDY3LTkykuzOaKGSMpLswONypJTepcoxIREelfFOhEusu/H4K//wimXwsfvjPoakSkm9U1NvHezpZGJau3l7N2RwUHaloalYwekMHRRTnMnjbc2+9WlENhbpoalYiISKcp0Il0h3eegue/BBNnwvn/A/phTaRP2VNZ126v24bdlTSGvEYl6cmJTCrMZuaUwnCjkklDs8lM1f92RUSka+n/LCJd7f2/w5LPwogTYfZvIFF/zETiVVPI8f6eylZ73daUlrOroi48pjA3jeLCHM6ePJjJhbkUF2YzaoAalYiISM+I6SdNMzsP+CmQCPzaOXdPm+M3AjcDTUAlcL1zbrV/7E7gOv/Ybc65F7uufJFeZscqWHQlFIyFKx6B5PSgKxKRGJXXNrDWvxl389faHRXUNYYASE40xg/O5rQJA5nsz7oVF+aQn5kScOUiItKfHTLQmVki8ABwDrAVeN3MljYHNt9C59yD/vhPAD8GzjOzycDlwNFAEfAnMzvKOdfUxZ9DJHj7NsP8iyE1G+Y8ARkFQVckIlE459i6r6bVXrc1O8rZUlYTHpOfkUxxYQ5zTxrld5jMYfzgLFKSEgKsXEREpL1YZuhmAOudcxsBzGwRMAsIBzrnXHnE+EzA+Y9nAYucc3XA+2a23j/fv7qgdpHeo2oPzL8IGuvg00shd3jQFYkIUNvQxLs7K1rtdVuzo5yK2kbA2946ZkAmU4bncfkJXpfJyYW5DMlJVaMSERGJC7EEumHAlojnW4ET2w4ys5uB24EU4MyI977W5r3Dorz3euB6gJEjR8ZSt0jvUV8FCy+FA1vh6qdh8KSgKxLpl3ZV1LKmzV63Dbsr8fuUkJGSSHFhDrOOLwo3Kpk4NJuMFO1zFRGR+BXL/8Wi/YrStXvBuQeAB8zsSuDrwDWH8d6HgIcASkpK2h0X6bWaGmDxNbB9BVy2AEaeFHRFIn1eY1OIjXuqwsGteenknsr68JhheekUF2Zz3jFDw3vdRhZkkKBGJSIi0sfEEui2AiMing8Hth9k/CLgF518r0j8cA6W3gbrX4ILfgaTzg+6IpE+50BNQ6smJatLy3l3ZyX1fqOSlMQEJgzJ4iMTB4f3uhUXZpOXoUYlIiLSP8QS6F4HJpjZGGAbXpOTKyMHmNkE59x7/tOZQPPjpcBCM/sxXlOUCcB/uqJwkcD96Zvw1kL4yNdg+jVBVyMS10Ihx5Z91X5oa1k2uW1/S6OSAZkpTC7K4dpTRof3uo0dlElyohqViIhI/3XIQOecazSzW4AX8W5b8Fvn3DtmdjewzDm3FLjFzM4GGoB9eMst8cctxmug0gjcrA6X0ie89gv4x31wwmfg9DuCrkYkrtTUN7FuZ+u9bmt3VFBZ5zUqSTAYOyiLaaPyueqkkeFbBAzKVqMSERGRtsy53rVlraSkxC1btizoMkQ6tupxeOI6KL4ALvk9JCQGXZFIr+ScY1dFHau3t+xzW11azqY9VeFGJVmpSRQXZoeblBQX5nDUkGzSU/TnSkRE+i8zW+6cK4llrFp7iRyOjX+FJ2+EUafCRb9WmBPxNTSFWL+rstVetzWlFZRVtTQqGZ6fTnFhDhdMaekyOTw/XY1KREREjoACnUisSt+CRXNg4FFw+UJITgu6IpFA7K+uDwe25mWT63dVUt/kNypJSmDikGzOKR4Snn2bVJhDbnpywJWLiIj0PQp0IrEoex/mz4b0PJjzhPddpI8LhRyby6pb7XVbXVpO6YHa8JiBWalMLsrhQ0cNDO91GzMwkyQ1KhEREekRCnQih1K5G+ZfBKFGmPMc5BQGXZFIzJ5asY17X1zH9v01FOWlc8e5E7lw6rB246rqGlm7o6JVcFu3o4Lqeq+PVWKCMW5QJjPGFLTa7zYoO7WnP5KIiIhEUKATOZi6ClgwG8pL4ZpnYNBRQVckErOnVmzjziWrqGnwQtm2/TXcuWQl+6rrGVmQ0Wqv26a9VTT3yMpOS6K4MIdLS0aEg9uEIVmkJWvPqIiISG+jQCfSkcZ6WHw17FgFVzwCI04IuiKRw/LDF9aGw1yzmoYQ33pmdfj5yIIMiguzufD4YeH9bsPz03V7ABERkTihQCcSTSgET98MG/4Msx6Ao84NuiKRgyqrqvdm3La3LJncHrHXra3HbjyZSUOzyU5ToxIREZF4pkAnEs1L/w9WLYaz7oKpc4KuRiSsKeTYtLeqXaOSneV14TGDs71GJVv31YRv1h1pWF46J4wu6MmyRUREpJso0Im09c+fw7/uhxk3wGm3B12N9GOVdY2sjQhtq0srWLejnNoG7/YASQnG+MFZnDJuIMWF2UwuzKW4MJsBWV6jkrZ76ADSkxO549yJgXweERER6XoKdCKR3noU/vh1OPqTcN49oH1E0gOcc2zbX9Pqvm5rdpSzeW91eExuejLFhdlcOWNUeK/bhCFZpCZ13KikuZtlLF0uRUREJD4p0Ik0W/8yPP05GP0h+OQvIUH30ZKuV9vQxPpdlaze3txh0vsqr21ZGjl6QAZHF+Uwe9pw7xYBRTkU5qZ1qlHJhVOHKcCJiIj0YQp0IgDb3oBH58KgYrh8ASTp3lpy5PZU1rXb67ZhdxVNIe/+AOnJiUwqzObjxxWF7+02aWg2man6q1lERERio58aRPZugAWXQOYAmPM4pOUGXZHEmcamEO/vqQrf06155m13RUujksLcNIoLczhn8pDwXrdRAzJJTNCyXhEREek8BTrp3yp2wrxPAg7mPAnZQ4OuSHq58toG1pZWtNwiYEc563ZUUNfoNSpJTjTGD87m9AmD/EYl3o258zNTAq5cRERE+iIFOum/asthwcVQtQeufQYGjg+6IulFnHNs3VfDOxFLJtfsKGdLWU14TH5GMpOLcph70qjwXrdxg7JISdL+SxEREekZCnTSPzXWwaNzYNcauOJRGDY96IokQLUNTazbUdFqr9va0goq/Hu4mcGYgZlMGZ7H5SeMDM+6DclJ7VSjEhEREZGuokAn/U8oBE/eCO+/4nWznHB20BVJD3HOsbuirt1et427K/H7lJCZksikwhxmTS0K73WbODSbjBT9dSkiIiK9j35Ckf7FOXjxq/DOEjjnbjju8qArkm7S0BRi4+6q8Ixb8+zbnsr68JhheekUF2Zz/jFDKfZn3UYWZJCgRiUiIiISJxTopH/5x33w71/ASTfDKbcFXY10kQM1DS1NSvy9bu/uqKS+yWtUkpKYwIQhWXxk4uBwcJtcmENuRnLAlYuIiIgcGQU66T/eXAh/+iYcewl89DvexiiJK6GQY8u+6nBwW+13m9y2v6VRyYDMFCYX5XDtqaP9LpO5jB2USXKiGpWIiIhI36NAJ/3Dey/B07fA2A/DrP+FBP1w39vV1Dexdoe3162lUUk5VfVNACQYjB2UxbRR+cw5aVT4FgGDstWoRERERPoPBTrp+7Yug8VXw9Bj4LL5kKT7gfUmzjl2lteFQ1vzfrdNe6rCjUqyU5OYVJjN7OnDw0smJw7NJi05MdjiRURERAKmQCd92573YMElkDUErnocUrODrqhfq28MsWF3Zau9bqu3l7OvuiE8Znh+OpMLc7hgShHFhTkcXZTD8Px0zbqJiIiIRKFAJ31XeSnMuwgSEmHuEsgaHHRF/cq+qvqIDpPeLQLW76qgocmbdktNSmDi0Gw+Onmot1yyKJdJhdnkpKlRiYiIiEisFOikb6o9AAtmQ00ZXPscFIwNuqI+KxRybNpb1Wqv25rSckoP1IbHDMpOpbgwh9OPGshkv8PkmIGZJKlRiYiIiMgRUaCTvqehFh65Enavg6sWQ9HxQVfUZ1TVNbJ2R+vgtm5HBdV+o5LEBGPcoExmjClgsr/XrdhvVCIiIiIiXU+BTvqWUBM8eT1sfhUu/g2MOzPoiuKSc47SA7Ut93bzu01u2luFa25UkpbE5MIcLi0Z4c26FeUwfnCWGpWIiIiI9CAFOuk7nIPnvwyrn4ZzvwfHzg66orhQ19jEezsrvSYlEcsmD9S0NCoZNSCD4qE5XHj8MCYX5VBcmM2wPDUqEREREQmaAp30HX//Ebz+KzjlNjj55qCr6ZX2VtaFQ1tzcFu/q5JG//4AackJTByaw/nHDg0vmZw4NJtsNSoRERER6ZUU6KRveONh+PN3YMrlcPa3gq4mcE0hx/t7qloFtzWl5ewsrwuPGZLjNSo5c9Lg8F63MQMzSUzQrJuIiIhIvFCgk/i37nl45vMw7iyYdT8k9K/OiZV1jayNCG2rSytYt6Oc2oYQAEkJxvjBWZw6biDF/l634sIcCjJ1g3URERGReKdAJ/Htg3/DY9dC4fFw6cOQGH9LA59asY17X1zH9v01FOWlc8e5E7lw6rB245xzbNtf49+Uu2Wv2wdl1eExeRnJFA/N4coZo8J73cYPziI1SY1KRERERPoiBTqJX7vXwSOXQc4wuOoxSM0KuqLD9tSKbdy5ZBU1DV7b/237a7hzySoamkJMGpoTDm2rS8tZW1pOeW0jAGYwekAmxwzL4dKS4eElk4W5aWpUIiIiItKPKNBJfDqwDeZdBIkpMHcJZA4MuqJOuffFdeEw16ymoYk7Hl8Zfp6RksjEodlccFxROLhNGppNZqr++IqIiIj0d/qJUOJPzT6YfzHUHoBP/QHyRwddUadt31/T4bEHrpzG5KIcRhVkkKBGJSIiIiISRUzdI8zsPDNbZ2brzewrUY7fbmarzWylmb1sZqMijjWZ2Zv+19KuLF76oYYaeOQKKNsAVyyEwilBV9RpuypqSU6M/kdwWF46M6cUMmZgpsKciIiIiHTokDN0ZpYIPACcA2wFXjezpc651RHDVgAlzrlqM7sJ+CFwmX+sxjl3fBfXLf1RqAme+Ax88BrM/i2MOT3oijpt+eZ9fG7BckIuRHKi0dDkwsfSkxO549yJAVYnIiIiIvEilhm6GcB659xG51w9sAiYFTnAOfcX51xzq73XgOFdW6b0e87Bc1+Etc/Cx34Ax1wUdEWd4pxj/mubufyhf5GalMgzt36Ie2cfx7C8dAxvZu77Fx0btculiIiIiEhbseyhGwZsiXi+FTjxIOOvA56PeJ5mZsuARuAe59xTbd9gZtcD1wOMHDkyhpKk33nlB7D8d3Da7XDiDUFX0ym1DU3c9fTbLF62lTOOGsRPLz+evIwUigtzFOBEREREpFNiCXTRNvC4KK9hZnOAEuCMiJdHOue2m9lY4M9mtso5t6HVyZx7CHgIoKSkJOq5pR9b9lv46/fh+Dlw1l1BV9Mp2/bXcNP85azceoBbzxzPF84+ikTtjRMRERGRIxRLoNsKjIh4PhzY3naQmZ0NfA04wzlX1/y6c267/32jmf0VmApsaPt+kajWPOsttZxwLlzwU+8GbHHmnxv2cMvCFdQ3hvjl3Omce/TQoEsSERERkT4ilj10rwMTzGyMmaUAlwOtulWa2VTgl8AnnHO7Il7PN7NU//FA4FQgspmKSMc2/wse/zQUTYNLfgeJ8XWXDeccv/77Rub+5j8UZKbw9C2nKsyJiIiISJc65E/IzrlGM7sFeBFIBH7rnHvHzO4GljnnlgL3AlnAY+bNoHzgnPsEUAz80sxCeOHxnjbdMUWi27kaHrkM8kbClYshJTPoig5LdX0jX35iFc+8tZ3zjh7KAaG/1wAAHa9JREFUjy49jizdCFxEREREupg517u2rJWUlLhly5YFXYYEaf8W+M1HAQfX/dELdXFk054qbpi3nPd2VfDf507kpjPGYXG4VFREREREgmFmy51zJbGM1ZSB9C7VZTD/Yqivgk8/H3dh7i9rd/H5RStISDD+71MzOP2oQUGXJCIiIiJ9mAKd9B711bDwMti3CeYugSFHB11RzEIhx/1/Wc9P/vQuxUNz+OXc6YwoyAi6LBERERHp4xTopHdoaoTHPwVbX4dLfw+jTwu6opiV1zZw+6Nv8ac1O/nk1GF875PHkp6SGHRZIiIiItIPKNBJ8JyDZ78A774AM/8HJs8KuqKYvbuzghvmLWdLWTXfvGAy15wyWvvlRERERKTHKNBJ8P7yXVgxD07/EpzwmaCridkfVpXy34+9RUZKEgs/exIzxhQEXZKIiIiI9DMKdBKs//wK/nYvTLsGPvLVoKuJSWNTiHv/uI5fvrKRqSPz+MVV0xmamxZ0WSIiIiLSDynQSXDeeQr+cAdMPB9m/hjiYKliWVU9tz2yglfX7+GqE0dy1wWTSU3SfjkRERERCYYCnQTj/b/Dks/CiBkw+7eQ2Pv/U3x72wFumLec3RV1/PDiKVx6woigSxIRERGRfq73/xQtfc+Ot2HRlVAwFq5YBMnpQVd0SE8s38pXn1xFQWYKj914MseNyAu6JBERERERBTrpYfs2ezcOT82GOU9ARu9uJFLfGOI7z63m4X9t5qSxBdx/5TQGZqUGXZaIiIiICKBAJz2pai/Mvwgaa+DTL0Lu8KArOqhd5bV8bsEbLNu8j89+aAxfPm8SSYkJQZclIiIiIhKmQCc9o74KFl4CB7bC1U/D4OKgKzqo5ZvLuGn+G1TUNvKzK6byieOKgi5JRERERKQdBTrpfk0NsPga2L4CLpsPI08KuqIOOeeY/+8PuPuZdyjKS+f3n55BcWFO0GWJiIiIiESlQCfdyzlYehusfwku+ClMmhl0RR2qbWji60+9zePLt/KRiYO477Kp5GYkB12WiIiIiEiHFOike738LXhrIXz4qzD92qCr6dC2/TXcOG85q7Yd4LazJvCFsyaQkND774snIiIiIv2bAp10n9cehFd/AiWfhjO+FHQ1Hfrn+j3c8sgKGhpD/OrqEs6ZPCTokkREREREYqJAJ93j7Sfgha9A8QVw/o/Aet9sl3OOX/19I/c8v5Zxg7J4cO50xg3KCrosEREREZGYKdBJ19v4V1hyA4w6BS76NSQkBl1RO1V1jXzpiZU8t7KU848dyg9nH0dWqv44iIiIiEh80U+w0rVK34JFc2DgBLh8ISSnBV1RO+/vqeLGect5b1cFX/nYJG44fSzWC2cQRUREREQORYFOuk7Z+zB/NqTnwZwnvO+9zMtrdvKFR98kMcH4/adn8KEJg4IuSURERESk0xTopGtU7ob5F0GoAeY8Bzm960bcoZDjZ39+j/v+9B5HF+Xw4JzpjCjICLosEREREZEjokAnR66uEhZeAuWlcM0zMOiooCtq5UBNA7c/+iYvr93FRdOG8b1PHktacu/b1yciIiIicrgU6OTINNbD4rlQutLbMzfihKAramXdjgpunL+cLWXV3D3raOaeNEr75URERESkz1Cgk84LheDpm2HDn2HWAzDxvKArauXZldv50uMryUxN4pHrT+KE0QVBlyQiIiIi0qUU6KTz/nQXrFoMZ/4/mDon6GrCGptC3PviOn75t41MH5XP/141jSE5va/bpoiIiIjIkVKgk8755/3wz5/DjOvhQ18Mupqwsqp6bn3kDf6xfi9zThrJXR8/mpSkhKDLEhERERHpFgp0cvhWLoY/fg0mXwjn3QO9ZE/aqq0HuHH+cnZX1vHD2VO4tGRE0CWJiIiIiHQrBTo5POtfhqdugtEfgosegoTe0S3y8eVb+eqTqxiYmcLjN57MlOG97x54IiIiIiJdTYFOYrftDXh0LgwqhssXQFJq0BVR3xji28+uZt5rmzll3AB+fsVUBmQFX5eIiIiISE9QoJPY7N0ACy6BzAEw53FIyw26InaW1/K5BW+wfPM+rj99LF86dyJJidovJyIiIiL9hwKdHFrFTph/EeBgzpOQPTToili2qYybFrxBZW0jP79iKhccVxR0SSIiIiIiPU6BTg6uthwWzIbKXXDNszBwfKDlOOeY99pm7n5mNcPz05l/3YlMHJodaE0iIiIiIkFRoJOONdbBo3Ng12q44lEYPj3Qcmobmvjak2/zxBtbOXPSYH5y2fHkpicHWpOIiIiISJAU6CS6UAievBHefwUufBAmnB1oOVv3VXPj/OW8va2cz581gc+fNYGEhN5xuwQRERERkaAo0El7zsGLX4V3lsDZ34Ljrwi0nFff28Otj7xBY5PjN9eUcFbxkEDrERERERHpLWJqCWhm55nZOjNbb2ZfiXL8djNbbWYrzexlMxsVcewaM3vP/7qmK4uXbvKPn8K/fwEnfQ5O/XxgZTjnePCVDVz9238zKDuVpbeepjAnIiIiIhLhkDN0ZpYIPACcA2wFXjezpc651RHDVgAlzrlqM7sJ+CFwmZkVAN8ASgAHLPffu6+rP4h0kTcfgT99A46ZDR/9Llgwyxqr6hr50uMreW5VKTOPLeSHs6eQmaoJZRERERGRSLHM0M0A1jvnNjrn6oFFwKzIAc65vzjnqv2nrwHD/cfnAi8558r8EPcScF7XlC5d7r2X4OmbYeyH4cJfQEIw93TbuLuSCx/4B8+/XcqdH5vE/VdOVZgTEREREYkilp+ShwFbIp5vBU48yPjrgOcP8t5hbd9gZtcD1wOMHDkyhpKky21dBouvhiFHw6XzICklkDL+tHon//XomyQlGvOuO5FTxw8MpA4RERERkXgQS6CLtubORR1oNgdveeUZh/Ne59xDwEMAJSUlUc8t3WjPelhwCWQNhjlPQFpOj5cQCjnue/k9fvbyexwzLIcH50xneH5Gj9chIiIiIhJPYgl0W4EREc+HA9vbDjKzs4GvAWc45+oi3vvhNu/9a2cKlW5SsQPmfxISEmHOEi/U9bADNQ3816Nv8ue1u5g9fTjfufAY0pITe7wOEREREZF4E0ugex2YYGZjgG3A5cCVkQPMbCrwS+A859yuiEMvAt8zs3z/+UeBO4+4aukatQdg/myoLoNrn4UB43q8hHU7Krh+3jK27avh27OOZs5Jo7CAGrGIiIiIiMSbQwY651yjmd2CF84Sgd86594xs7uBZc65pcC9QBbwmP/D+AfOuU8458rM7Nt4oRDgbudcWbd8Ejk8DbWw6CrYvQauegyKpvZ4Cc+8tZ0vPb6SrLQkHr3hJKaPKujxGkRERERE4pk517u2rJWUlLhly5YFXUbfFmqCxz8Fq5+Gi34FUy7t0cs3NoX4wQtr+dXf32f6qHx+cdU0Buek9WgNIiIiIiK9lZktd86VxDJWveD7G+fg+S97Ye6j3+3xMLe3so5bH1nBPzfs5eqTR/H1mZNJSQrm9ggiIiIiIvFOga6/+fv/wOu/glNuhVNu6dFLr9y6nxvnLWdPVT0/uuQ4Zk8ffug3iYiIiIhIhxTo+pM35sGfvw1TLoOz7+7RSy9etoWvP/U2g7JSeeLGUzh2eG6PXl9EREREpC9SoOsv1r0Az3wexp0Fsx6AhJ5Z5ljfGOJbz7zDgn9/wKnjB/DzK6ZRkBnMTctFRERERPoaBbr+YMt/4LFroXAKXPowJCb3yGV3ltdy0/zlvPHBfm44Yyx3fHQiSYnaLyciIiIi0lUU6Pq63etg4aWQUwhXPgapWT1y2dc3lXHT/Deorm/kgSunMXNKYY9cV0RERESkP1Gg68vKt8O8iyAhGeYsgaxB3X5J5xwP/2sz3352NSMKMlj42RM5akh2t19XRERERKQ/UqDrq2r2wfyLofYAfOo5KBjT7ZesbWjiq0tWsWTFNs6aNJgfX3Y8uek9s7xTRERERKQ/UqDrixpq4JErYe96uOpxKDyu2y+5payaG+cvZ3VpOf919lHceuZ4EhKs268rIiIiItKfKdD1NaEmeOIz8MG/YPZvYewZ3X7Jv7+3m1sfWUFTyPGba0o4c9KQbr+miIiIiIgo0PUtzsFzX4S1z8J5P4BjLurmyzkefGUj9764lgmDs/nl3OmMHpjZrdcUEREREZEWCnR9ySs/hOW/g9P+C066sVsvVVnXyB2PvcXzb+9g5pRCfnjxFDJT9Z+TiIiIiEhP0k/gfcWy38FfvwfHXwVnfaNbL7VxdyU3zFvOht2VfO38Yj7zoTGYab+ciIiIiEhPU6DrC9Y8C8/dDhM+Chf8FLoxXL20eie3P/omyUkJzL/uRE4ZP7DbriUiIiIiIgenQBfvNv8LnrgOiqbBJf8Hid1zm4BQyHHfn97lZ39ez5ThufxiznSG5aV3y7VERERERCQ2CnTxbOdqeOQyyB0BVy6GlO5pSHKguoEvPLqCv6zbzSXTh/PtC48hLTmxW64lIiIiIiKxU6CLVwe2ejcOT0qHuUsgc0C3XGbtjnJumLec7ftr+M6Fx3DViSO1X05EREREpJdQoItH1WUw7yKor4JP/QHyRnbLZZa+tZ0vP76S7LQkFl1/MtNH5XfLdUREREREpHMU6OJNfTU8cjns2+TNzA09pssv0dgU4p7n1/LrV9+nZFQ+/3vVNAbnpHX5dURERERE5Mgo0MWTpkZ4/NOw5T9w6e9h9Gldfok9lXXcsvANXttYxjUnj+JrMyeTkpTQ5dcREREREZEjp0AXL5yDZ78A7z4P5/8IJs/q8ku8tWU/N85fTllVPf9zyXFcPH14l19DRERERES6jgJdvPjLd2HFPDj9Dpjx2S4//aOvf8D/e+odBmWn8sRNp3DMsNwuv4aIiIiIiHQtBbp48J9fwd/uhWlXw0e+1qWnrmts4lvPrGbhvz/gtPED+fkVU8nPTOnSa4iIiIiISPdQoOvtVj8Nf7gDJp4PM38CXXjLgB0HarlpwXJWfLCfG88Yxx3nTiQxQbckEBERERGJFwp0vdmmV+GJz8CIGXDxbyCx6/51/ef9Mj634A2q6xv5xVXT+NixhV12bhERERER6RkKdL3VjrfhkSsgfwxcsQhSMrrktM45/u+fm/juc2sYWZDBI589kQlDsrvk3CIiIiIi0rMU6HqjfZth/sWQkuXday6joEtOW1PfxNeeXMWSFds4u3gIP77sOHLSkrvk3CIiIiIi0vMU6Hqbqr1emGusgU+/CLldc+uALWXV3DBvOWt2lPPFc47i5o+MJ0H75URERERE4poCXW9SXwULL4UDW2DuUzC4uEtO+7d3d3PbohWEQo7fXnMCH5k0uEvOKyIiIiIiwVKg6y2aGuCxa2H7G3DpPBh18hGf0jnH//51Az/64zomDsnmwTnTGT0w88hrFRERERGRXkGBrjdwDpbeBu/9ET5+HxR//IhPWVnXyH8vfosX3tnBBccV8YOLjyUjRf+6RURERET6Ev2E3xu8/C14ayF8+E4o+dQRn27D7kquf3gZm/ZW8/WZxVx32hisC+9fJyIiIiIivYMCXdBeexBe/QlM/xSc8eUjPt2L7+zgi4vfIjUpgXnXzeCUcQO7oEgREREREemNFOiC9PYSeOErMOnjMPN/4Ahm0ZpCjp+89C73/2U9xw3P5RdzplOUl96FxYqIiIiISG+jQBeUja/AkzfAyJPh4t9AQmKnT7W/up7PL3qTV97dzWUlI/jWrKNJS+78+UREREREJD4kxDLIzM4zs3Vmtt7MvhLl+Olm9oaZNZrZ7DbHmszsTf9raVcVHtdK34JFV8GA8XDFQkhO6/SpVm8v5xP3/4N/btjD9z55LPdcfKzCnIiIiIhIP3HIGTozSwQeAM75/+3de5CV9X3H8feXdZVVERVvyEWMEibeELKikaRNbLy0mmjUAl5jY6pDwmjaaqNNm1anjekktSbRRG2iM+liQAUppta7NuNdLguISipIAUFBzaJU5Lbf/rEnujq4e3bdw8M5+37N7Jzn/PacZz87PMPs5zzP7/cAK4BnI2JmZj7f7mXLgAuAy7ayi/WZeWQPZK0Nb74MTWdC3/5wzp3QsEe3d/Ufza/w7Wnz6d9Qz9SLP8Pood3flyRJkqTqU84ll2OAlzJzCUBETAFOBd4rdJm5tPS91gpkrB3r1kDT6dC6CS74NfQf1K3dbNrSyjX3vMgtj7/MmGF7cv05o9inX/fP8kmSJEmqTuUUukHA8nbPVwBHd+Fn9I2IWcBm4PuZOePDL4iIi4CLAIYOHdqFXVeRDevgtnHw1ir46kzYe0S3dvP6ug18c/Icnn75TS44dhjfOflT1NeVdeWsJEmSpBpTTqHb2tKL2YWfMTQzV0bEJ4CHI2JBZi7+wM4ybwZuBmhsbOzKvqvD5o1w+/ltc+cm3AZDxnRrN83LW5jYNJs3/28j/zp+JF8ZNbiHg0qSJEmqJuWc2lkBDGn3fDCwstwfkJkrS49LgEeBUV3IV/1aW2HmJFj8EHzpOhhxUrd2M+WZZYy78Unq+gTTJh5rmZMkSZJUVqF7FhgeEQdGxI7ABKCs1SojYo+I2Km0vRcwlnZz73qFB78L86fCcX8Lo8/v8ts3bN7CldMXcMX0BRz9iT25e9JnOWxQ/woElSRJklRtOr3kMjM3R8Qk4D6gDrglMxdGxNXArMycGRFHAXcBewBfioirMvNQ4FPATaXFUvrQNoeu9xS6J66HJ34CR/05fG5rC4B2bNXa9UxsmkPz8ha+8fmD+KsTRlDXp/s3H5ckSZJUWyJz+5qy1tjYmLNmzSo6xsc3/w6Y/nU45FQ489Yu3zj8qSVvMOm2OazfuIV/GTeSkw4bWKGgkiRJkrYnETE7MxvLeW05i6KoqxY/DDMmwrDPwVdu7lKZy0xufXwp/3TPCxwwYGemXHQMB+/Tr4JhJUmSJFUrC11PWzkXpp7XdluCCZOhvvz7w63fuIUrp89nRvNKjj9kX64dN5J+fesrGFaSJElSNbPQ9aQ3FkPTmdCwJ5xzJ/Qtf/GSZW+8w8VNs3nx1be47IRP8o3PH0wf58tJkiRJ6oCFrqe8/Ro0nQ7ZCudNh93Kn/P26KLVXDqlmczklguO4gsj9qlgUEmSJEm1wkLXEza8DZPPhHWr4at3w17Dy3pbZvLTRxfzw/sXMWLfftx03qc5YMAuFQ4rSZIkqVZY6D6uzRth6rnw2kI4eyoMLmsxGt5+dxOX3TGP+xa+xpdH7s/3zzicnXf0n0OSJElS+WwQH0dra9tqlksehdN+BsOPL+ttL61ex8X/Poulb7zD351yCF8bO4wI58tJkiRJ6hoLXXdlwv3fgefuhC/+Axx5dllvu/e5V7nsjnnstEMfmi48ms8cNKCiMSVJkiTVLgtddz3+I3jqp3D0RBj7rU5fvqU1ufaBRdzwyGJGDtmdG88dzcD+DdsgqCRJkqRaZaHrjuZfwYN/D4edASd+Dzq5XLLlnY1cMqWZ3/x2DROOGsJVpx7KTjuUf7NxSZIkSdoaC11X/c+DMHMSHPiHbfPm+vTp8OXPr3yLi5tm8draDVxz+uGcNWboNgoqSZIkqdZZ6Doz/3Z46GpYuwJ23Rve+R3scwiMb4IddurwrTPmvsIV0+eze8OOTL34GEYN3WMbhZYkSZLUG1joOjL/drj7Eti0vu35utVAwOjzoe9uH/m2TVta+d49L3Dr40sZc+Ce3HD2aPbu13H5kyRJkqSu6vh6wd7uoavfL3PvybYFUT7Cmrc3cM7Pn+bWx5fytbEHMvnrR1vmJEmSJFWEZ+g6snZFl8bnLvsdE5vm0LJ+I9eNP5LTRg2qYDhJkiRJvZ1n6DrSf3DZ47c9vYzxNz1F/Q7BtInHWuYkSZIkVZyFriN/9F2o/9C94uob2sZLNmzewhXT5vM3dy3gmIMGcPekz3Lo/v23cVBJkiRJvZGXXHbkiHFtj79f5bL/4LYyVxpf2bKeiZPnMG95C5O+cDB/cfwnqevT8T3pJEmSJKmnWOg6c8S494tdO08ufoNJt81hw+ZWbjz305x02H4FhJMkSZLUm1nouigz+cVjL3PNf73IsAE7c9N5jRy8z65Fx5IkSZLUC1noOjFj7iv84L5FrGxZz379+zKwf1/mLGvhxEP35Yd/OpJ+feuLjihJkiSpl7LQdWDG3Fe4cvoC1m/aAsCqte+yau27nHz4fvzkrNH0cb6cJEmSpAK5ymUHfnDfovfKXHvNy9da5iRJkiQVzkLXgZUt67s0LkmSJEnbkoWuA/vv3tClcUmSJEnalix0Hbj8xBE01Nd9YKyhvo7LTxxRUCJJkiRJep+LonTgtFGDAN5b5XL/3Ru4/MQR741LkiRJUpEsdJ04bdQgC5wkSZKk7ZKXXEqSJElSlbLQSZIkSVKVstBJkiRJUpWy0EmSJElSlbLQSZIkSVKVstBJkiRJUpWKzCw6wwdExBrgf4vOsRV7Aa8XHUI1zWNMleTxpUry+FIleXypkrbX4+uAzNy7nBdud4VuexURszKzsegcql0eY6okjy9VkseXKsnjS5VUC8eXl1xKkiRJUpWy0EmSJElSlbLQle/mogOo5nmMqZI8vlRJHl+qJI8vVVLVH1/OoZMkSZKkKuUZOkmSJEmqUhY6SZIkSapSFroyRMRJEbEoIl6KiCuKzqPaEhG3RMTqiHiu6CyqLRExJCIeiYgXImJhRFxadCbVlojoGxHPRMS80jF2VdGZVHsioi4i5kbEr4vOotoSEUsjYkFENEfErKLzdJdz6DoREXXAb4HjgRXAs8BZmfl8ocFUMyLiD4B1wC8z87Ci86h2RMRAYGBmzomIfsBs4DT//1JPiYgAdsnMdRFRDzwGXJqZTxUcTTUkIv4SaAR2y8xTis6j2hERS4HGzNwebyxeNs/QdW4M8FJmLsnMjcAU4NSCM6mGZOZvgDeLzqHak5mrMnNOaftt4AVgULGpVEuyzbrS0/rSl58Uq8dExGDgZODnRWeRtlcWus4NApa3e74C/yCSVGUiYhgwCni62CSqNaXL4ZqB1cADmekxpp50HfDXQGvRQVSTErg/ImZHxEVFh+kuC13nYitjfvooqWpExK7ANOBbmflW0XlUWzJzS2YeCQwGxkSEl46rR0TEKcDqzJxddBbVrLGZORr4Y+CbpWkwVcdC17kVwJB2zwcDKwvKIkldUprXNA2YnJnTi86j2pWZLcCjwEkFR1HtGAt8uTTPaQpwXEQ0FRtJtSQzV5YeVwN30TbVqupY6Dr3LDA8Ig6MiB2BCcDMgjNJUqdKC1b8AnghM68tOo9qT0TsHRG7l7YbgC8CLxabSrUiM6/MzMGZOYy2v78ezsxzC46lGhERu5QWDCMidgFOAKpyxXELXScyczMwCbiPtgUFbs/MhcWmUi2JiF8BTwIjImJFRFxYdCbVjLHAebR9qt1c+vqTokOppgwEHomI+bR9APpAZrq0vKRqsC/wWETMA54B/jMz7y04U7d42wJJkiRJqlKeoZMkSZKkKmWhkyRJkqQqZaGTJEmSpCploZMkSZKkKmWhkyRJkqQqZaGTJNWsiNjS7pYNzRFxRQ/ue1hEVOU9iyRJtWOHogNIklRB6zPzyKJDSJJUKZ6hkyT1OhGxNCL+OSKeKX0dXBo/ICIeioj5pcehpfF9I+KuiJhX+jq2tKu6iPi3iFgYEfdHRENhv5QkqVey0EmSalnDhy65HN/ue29l5hjgeuC60tj1wC8z8whgMvDj0viPgf/OzJHAaGBhaXw4cENmHgq0AGdU+PeRJOkDIjOLziBJUkVExLrM3HUr40uB4zJzSUTUA69m5oCIeB0YmJmbSuOrMnOviFgDDM7MDe32MQx4IDOHl55/G6jPzH+s/G8mSVIbz9BJknqr/Ijtj3rN1mxot70F56ZLkrYxC50kqbca3+7xydL2E8CE0vY5wGOl7YeAiQARURcRu22rkJIkdcRPEiVJtawhIprbPb83M39/64KdIuJp2j7cPKs0dglwS0RcDqwB/qw0filwc0RcSNuZuInAqoqnlySpE86hkyT1OqU5dI2Z+XrRWSRJ+ji85FKSJEmSqpRn6CRJkiSpSnmGTpIkSZKqlIVOkiRJkqqUhU6SJEmSqpSFTpIkSZKqlIVOkiRJkqrU/wOnf5NlQpnwjwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x203af5d34a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "\n",
    "# for i in [1, 2, 3]:\n",
    "#   plt.subplot(3, 1, i)\n",
    "#   plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.542284\n",
      "(Epoch 0 / 5) train acc: 0.122000; val_acc: 0.153000\n",
      "(Iteration 11 / 200) loss: 1.897568\n",
      "(Iteration 21 / 200) loss: 2.053484\n",
      "(Iteration 31 / 200) loss: 1.710979\n",
      "(Epoch 1 / 5) train acc: 0.358000; val_acc: 0.297000\n",
      "(Iteration 41 / 200) loss: 1.588012\n",
      "(Iteration 51 / 200) loss: 1.649889\n",
      "(Iteration 61 / 200) loss: 1.582486\n",
      "(Iteration 71 / 200) loss: 1.678554\n",
      "(Epoch 2 / 5) train acc: 0.474000; val_acc: 0.351000\n",
      "(Iteration 81 / 200) loss: 1.440607\n",
      "(Iteration 91 / 200) loss: 1.714120\n",
      "(Iteration 101 / 200) loss: 1.484540\n",
      "(Iteration 111 / 200) loss: 1.482198\n",
      "(Epoch 3 / 5) train acc: 0.511000; val_acc: 0.380000\n",
      "(Iteration 121 / 200) loss: 1.512816\n",
      "(Iteration 131 / 200) loss: 1.285589\n",
      "(Iteration 141 / 200) loss: 1.513641\n",
      "(Iteration 151 / 200) loss: 1.260784\n",
      "(Epoch 4 / 5) train acc: 0.571000; val_acc: 0.364000\n",
      "(Iteration 161 / 200) loss: 1.094462\n",
      "(Iteration 171 / 200) loss: 1.413974\n",
      "(Iteration 181 / 200) loss: 1.063530\n",
      "(Iteration 191 / 200) loss: 1.332217\n",
      "(Epoch 5 / 5) train acc: 0.583000; val_acc: 0.401000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.757904\n",
      "(Epoch 0 / 5) train acc: 0.151000; val_acc: 0.100000\n",
      "(Iteration 11 / 200) loss: 2.113823\n",
      "(Iteration 21 / 200) loss: 1.919814\n",
      "(Iteration 31 / 200) loss: 2.012744\n",
      "(Epoch 1 / 5) train acc: 0.336000; val_acc: 0.303000\n",
      "(Iteration 41 / 200) loss: 1.860277\n",
      "(Iteration 51 / 200) loss: 1.998715\n",
      "(Iteration 61 / 200) loss: 1.653692\n",
      "(Iteration 71 / 200) loss: 1.742092\n",
      "(Epoch 2 / 5) train acc: 0.413000; val_acc: 0.307000\n",
      "(Iteration 81 / 200) loss: 1.784915\n",
      "(Iteration 91 / 200) loss: 1.519975\n",
      "(Iteration 101 / 200) loss: 1.435093\n",
      "(Iteration 111 / 200) loss: 1.463651\n",
      "(Epoch 3 / 5) train acc: 0.485000; val_acc: 0.334000\n",
      "(Iteration 121 / 200) loss: 1.511428\n",
      "(Iteration 131 / 200) loss: 1.650331\n",
      "(Iteration 141 / 200) loss: 1.537632\n",
      "(Iteration 151 / 200) loss: 1.529421\n",
      "(Epoch 4 / 5) train acc: 0.510000; val_acc: 0.341000\n",
      "(Iteration 161 / 200) loss: 1.314994\n",
      "(Iteration 171 / 200) loss: 1.366581\n",
      "(Iteration 181 / 200) loss: 1.305786\n",
      "(Iteration 191 / 200) loss: 1.430394\n",
      "(Epoch 5 / 5) train acc: 0.536000; val_acc: 0.348000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\lib\\site-packages\\matplotlib\\cbook\\deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x203af5b2a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer: \n",
    "在AdaGrad中，分母cache随着迭代的进行一直在累加，所以更新步长会减小的很快，在RMSProp中对其进行了改进，将分母写成`cache = decay_rate*cache + (1-dacay_rate)*(dw**2)`，这样分母随着迭代的进行会有一个衰减量，不会增加的过快，但也能起到逐元素缩放的作用，而Adam是将PMSProp进行了改进，将分子的dw也进行了滑动平均，即将动量加入其中，而后又对分子和分母进行偏差矫正，所以开始步长不会过大，综上所述，Adam是这些优化方法中最好的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.780103\n",
      "(Epoch 0 / 10) train acc: 0.080000; val_acc: 0.102000\n",
      "(Iteration 101 / 4900) loss: 2.177044\n",
      "(Iteration 201 / 4900) loss: 2.028392\n",
      "(Iteration 301 / 4900) loss: 1.926874\n",
      "(Iteration 401 / 4900) loss: 1.972531\n",
      "(Epoch 1 / 10) train acc: 0.357000; val_acc: 0.336000\n",
      "(Iteration 501 / 4900) loss: 1.911892\n",
      "(Iteration 601 / 4900) loss: 2.051134\n",
      "(Iteration 701 / 4900) loss: 1.890796\n",
      "(Iteration 801 / 4900) loss: 1.907021\n",
      "(Iteration 901 / 4900) loss: 1.704244\n",
      "(Epoch 2 / 10) train acc: 0.420000; val_acc: 0.406000\n",
      "(Iteration 1001 / 4900) loss: 1.680063\n",
      "(Iteration 1101 / 4900) loss: 1.722113\n",
      "(Iteration 1201 / 4900) loss: 1.629667\n",
      "(Iteration 1301 / 4900) loss: 1.772981\n",
      "(Iteration 1401 / 4900) loss: 1.548940\n",
      "(Epoch 3 / 10) train acc: 0.436000; val_acc: 0.410000\n",
      "(Iteration 1501 / 4900) loss: 1.683238\n",
      "(Iteration 1601 / 4900) loss: 1.750186\n",
      "(Iteration 1701 / 4900) loss: 1.566215\n",
      "(Iteration 1801 / 4900) loss: 1.858547\n",
      "(Iteration 1901 / 4900) loss: 1.490894\n",
      "(Epoch 4 / 10) train acc: 0.453000; val_acc: 0.469000\n",
      "(Iteration 2001 / 4900) loss: 1.754480\n",
      "(Iteration 2101 / 4900) loss: 1.510903\n",
      "(Iteration 2201 / 4900) loss: 1.657183\n",
      "(Iteration 2301 / 4900) loss: 1.694781\n",
      "(Iteration 2401 / 4900) loss: 1.599522\n",
      "(Epoch 5 / 10) train acc: 0.455000; val_acc: 0.464000\n",
      "(Iteration 2501 / 4900) loss: 1.756438\n",
      "(Iteration 2601 / 4900) loss: 1.575501\n",
      "(Iteration 2701 / 4900) loss: 1.554481\n",
      "(Iteration 2801 / 4900) loss: 1.700437\n",
      "(Iteration 2901 / 4900) loss: 1.632301\n",
      "(Epoch 6 / 10) train acc: 0.465000; val_acc: 0.467000\n",
      "(Iteration 3001 / 4900) loss: 1.740153\n",
      "(Iteration 3101 / 4900) loss: 1.791316\n",
      "(Iteration 3201 / 4900) loss: 1.504499\n",
      "(Iteration 3301 / 4900) loss: 1.637577\n",
      "(Iteration 3401 / 4900) loss: 1.541610\n",
      "(Epoch 7 / 10) train acc: 0.474000; val_acc: 0.481000\n",
      "(Iteration 3501 / 4900) loss: 1.710678\n",
      "(Iteration 3601 / 4900) loss: 1.756885\n",
      "(Iteration 3701 / 4900) loss: 1.604005\n",
      "(Iteration 3801 / 4900) loss: 1.516358\n",
      "(Iteration 3901 / 4900) loss: 1.593453\n",
      "(Epoch 8 / 10) train acc: 0.493000; val_acc: 0.488000\n",
      "(Iteration 4001 / 4900) loss: 1.386578\n",
      "(Iteration 4101 / 4900) loss: 1.626786\n",
      "(Iteration 4201 / 4900) loss: 1.478567\n",
      "(Iteration 4301 / 4900) loss: 1.417155\n",
      "(Iteration 4401 / 4900) loss: 1.595953\n",
      "(Epoch 9 / 10) train acc: 0.475000; val_acc: 0.499000\n",
      "(Iteration 4501 / 4900) loss: 1.512480\n",
      "(Iteration 4601 / 4900) loss: 1.733596\n",
      "(Iteration 4701 / 4900) loss: 1.597026\n",
      "(Iteration 4801 / 4900) loss: 1.485701\n",
      "(Epoch 10 / 10) train acc: 0.507000; val_acc: 0.518000\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# learning_rate = [1e-2, 1e-3, 1e-4,]\n",
    "learning_rate = 1e-3\n",
    "train_data = data\n",
    "model = FullyConnectedNet([256, 256, 256, 256, 256], weight_scale=5e-2, \n",
    "                          dropout=0.5, normalization='layernorm', reg=0.0)\n",
    "solver = Solver(model, train_data,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                    'learning_rate': learning_rate\n",
    "                },\n",
    "                lr_decay=0.9,\n",
    "                verbose=True, print_every=100)\n",
    "solver.train()\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x19b5c446c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(solver.loss_history[10:], '-', label='adam')\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Train-loss')\n",
    "plt.legend(loc='upper center')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(solver.train_acc_history, label='train acc')\n",
    "plt.plot(solver.val_acc_history, label='val acc')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuarcy')\n",
    "plt.legend(loc='upper center')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 还没有加入正则化所以有过拟合现象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.518\n",
      "Test set accuracy:  0.491\n"
     ]
    }
   ],
   "source": [
    "best_model = solver.model\n",
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
